diff --git a/deprecated/plugins/org.eclipse.uml2/model/UML2.ecore b/deprecated/plugins/org.eclipse.uml2/model/UML2.ecore
index 9194051..c4fb4a0 100644
--- a/deprecated/plugins/org.eclipse.uml2/model/UML2.ecore
+++ b/deprecated/plugins/org.eclipse.uml2/model/UML2.ecore
@@ -1892,8 +1892,7 @@
       <eAnnotations source="subsets" references="#//Namespace/%duplicates%/ownedMember"/>
     </eStructuralFeatures>
     <eStructuralFeatures xsi:type="ecore:EReference" name="ownedStateMachine" ordered="false"
-        upperBound="-1" eType="#//StateMachine" volatile="true" containment="true"
-        eOpposite="#//StateMachine/stateMachine_redefinitionContext">
+        upperBound="-1" eType="#//StateMachine" containment="true" eOpposite="#//StateMachine/stateMachine_redefinitionContext">
       <eAnnotations source="redefines" references="#//BehavioredClassifier/ownedBehavior"/>
     </eStructuralFeatures>
   </eClassifiers>
@@ -1918,8 +1917,7 @@
       <eAnnotations source="subsets" references="#//Element/ownedElement"/>
     </eStructuralFeatures>
     <eStructuralFeatures xsi:type="ecore:EReference" name="group" ordered="false"
-        upperBound="-1" eType="#//ActivityGroup" volatile="true" containment="true"
-        eOpposite="#//ActivityGroup/activityGroup_activity">
+        upperBound="-1" eType="#//ActivityGroup" containment="true" eOpposite="#//ActivityGroup/activityGroup_activity">
       <eAnnotations source="subsets" references="#//Element/ownedElement"/>
     </eStructuralFeatures>
     <eStructuralFeatures xsi:type="ecore:EReference" name="node" ordered="false" upperBound="-1"
@@ -2222,7 +2220,7 @@
       <eAnnotations source="subsets" references="#//Element/owner"/>
     </eStructuralFeatures>
     <eStructuralFeatures xsi:type="ecore:EReference" name="activityGroup_activity"
-        eType="#//Activity" volatile="true" transient="true" eOpposite="#//Activity/group">
+        eType="#//Activity" transient="true" eOpposite="#//Activity/group">
       <eAnnotations source="subsets" references="#//Element/owner"/>
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
         <details key="documentation" value="Activity containing the group."/>
@@ -3533,7 +3531,7 @@
       <eAnnotations source="redefines" references="#//RedefinableElement/%duplicates%/redefinedElement"/>
     </eStructuralFeatures>
     <eStructuralFeatures xsi:type="ecore:EReference" name="stateMachine_redefinitionContext"
-        eType="#//BehavioredClassifier" volatile="true" transient="true" eOpposite="#//BehavioredClassifier/ownedStateMachine">
+        eType="#//BehavioredClassifier" transient="true" eOpposite="#//BehavioredClassifier/ownedStateMachine">
       <eAnnotations source="redefines" references="#//RedefinableElement/redefinitionContext"/>
     </eStructuralFeatures>
   </eClassifiers>
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Action.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Action.java
index ec4d721..4642bd8 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Action.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Action.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Action.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Action.java,v 1.12 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -90,7 +90,6 @@
 	EList getOutputs();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.OutputPin} with the specified '<em><b>Name</b></em>' from the '<em><b>Output</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -119,7 +118,6 @@
 	EList getInputs();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.InputPin} with the specified '<em><b>Name</b></em>' from the '<em><b>Input</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Activity.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Activity.java
index 67768ca..dc78004 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Activity.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Activity.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Activity.java,v 1.10 2005/06/15 20:06:01 khussey Exp $
+ * $Id: Activity.java,v 1.11 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -223,7 +223,7 @@
 	 * @return the value of the '<em>Group</em>' containment reference list.
 	 * @see org.eclipse.uml2.UML2Package#getActivity_Group()
 	 * @see org.eclipse.uml2.ActivityGroup#getActivityGroup_activity
-	 * @model type="org.eclipse.uml2.ActivityGroup" opposite="activityGroup_activity" containment="true" volatile="true" ordered="false"
+	 * @model type="org.eclipse.uml2.ActivityGroup" opposite="activityGroup_activity" containment="true" ordered="false"
 	 * @generated
 	 */
 	EList getGroups();
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityEdge.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityEdge.java
index 8d53e19..42b3c8c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityEdge.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityEdge.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityEdge.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ActivityEdge.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -153,7 +153,6 @@
 	EList getInGroups();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Guard</b></em>' containment reference.
 	 * <!-- begin-user-doc -->
@@ -209,7 +208,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityEdge} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityGroup.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityGroup.java
index d6a8e71..26ae5f8 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityGroup.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityGroup.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityGroup.java,v 1.8 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ActivityGroup.java,v 1.9 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -59,7 +59,6 @@
 	ActivityGroup getSuperGroup();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Activity Group activity</b></em>' container reference.
 	 * It is bidirectional and its opposite is '{@link org.eclipse.uml2.Activity#getGroups <em>Group</em>}'.
@@ -76,7 +75,7 @@
 	 * @see #setActivityGroup_activity(Activity)
 	 * @see org.eclipse.uml2.UML2Package#getActivityGroup_ActivityGroup_activity()
 	 * @see org.eclipse.uml2.Activity#getGroups
-	 * @model opposite="group" volatile="true"
+	 * @model opposite="group"
 	 * @generated
 	 */
 	Activity getActivityGroup_activity();
@@ -92,7 +91,6 @@
 	void setActivityGroup_activity(Activity value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Subgroup</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.ActivityGroup}.
@@ -108,7 +106,6 @@
 	EList getSubgroups();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Contained Edge</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.ActivityEdge}.
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityNode.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityNode.java
index 48a7461..3f73da3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityNode.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityNode.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityNode.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ActivityNode.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -122,7 +122,6 @@
 	EList getInGroups();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Activity</b></em>' container reference.
 	 * It is bidirectional and its opposite is '{@link org.eclipse.uml2.Activity#getNodes <em>Node</em>}'.
@@ -169,7 +168,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityNode} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityPartition.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityPartition.java
index 5969ddd..254ebba 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityPartition.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/ActivityPartition.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityPartition.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ActivityPartition.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -131,7 +131,6 @@
 	EList getContainedEdges();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityEdge} with the specified '<em><b>Name</b></em>' from the '<em><b>Contained Edge</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -162,7 +161,6 @@
 	EList getContainedNodes();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityNode} with the specified '<em><b>Name</b></em>' from the '<em><b>Contained Node</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -193,7 +191,6 @@
 	EList getSubgroups();
 
 
-
     /**
      * Retrieves the {@link org.eclipse.uml2.ActivityPartition} with the specified '<em><b>Name</b></em>' from the '<em><b>Subgroup</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioralFeature.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioralFeature.java
index 9e32b8f..8856f7d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioralFeature.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioralFeature.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: BehavioralFeature.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: BehavioralFeature.java,v 1.12 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -130,7 +130,6 @@
 	EList getParameters();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Parameter} with the specified '<em><b>Name</b></em>' from the '<em><b>Parameter</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioredClassifier.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioredClassifier.java
index 530b2d8..0108c1b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioredClassifier.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/BehavioredClassifier.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: BehavioredClassifier.java,v 1.13 2005/11/04 22:23:04 khussey Exp $
+ * $Id: BehavioredClassifier.java,v 1.14 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -231,13 +231,12 @@
 	 * @return the value of the '<em>Owned State Machine</em>' containment reference list.
 	 * @see org.eclipse.uml2.UML2Package#getBehavioredClassifier_OwnedStateMachine()
 	 * @see org.eclipse.uml2.StateMachine#getStateMachine_redefinitionContext
-	 * @model type="org.eclipse.uml2.StateMachine" opposite="stateMachine_redefinitionContext" containment="true" volatile="true" ordered="false"
+	 * @model type="org.eclipse.uml2.StateMachine" opposite="stateMachine_redefinitionContext" containment="true" ordered="false"
 	 * @generated
 	 */
 	EList getOwnedStateMachines();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.StateMachine} with the specified '<em><b>Name</b></em>' from the '<em><b>Owned State Machine</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Class.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Class.java
index 4547d85..2eb519e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Class.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Class.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Class.java,v 1.21 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Class.java,v 1.22 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -156,7 +156,6 @@
 	EList getSuperClasses();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Class} with the specified '<em><b>Name</b></em>' from the '<em><b>Super Class</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Classifier.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Classifier.java
index 6189512..34f3b86 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Classifier.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Classifier.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Classifier.java,v 1.21 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Classifier.java,v 1.22 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -110,7 +110,6 @@
 	EList getFeatures();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Feature} with the specified '<em><b>Name</b></em>' from the '<em><b>Feature</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -236,7 +235,6 @@
 	EList getAttributes();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Property} with the specified '<em><b>Name</b></em>' from the '<em><b>Attribute</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Component.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Component.java
index b8478a4..0b1d589 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Component.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Component.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Component.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Component.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -198,7 +198,6 @@
 	EList getOwnedMembers();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.PackageableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Owned Member</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Constraint.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Constraint.java
index 38bbb29..a9ab854 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Constraint.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Constraint.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Constraint.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Constraint.java,v 1.12 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -69,7 +69,6 @@
 	Namespace getContext();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Namespace</b></em>' container reference.
 	 * It is bidirectional and its opposite is '{@link org.eclipse.uml2.Namespace#getOwnedRules <em>Owned Rule</em>}'.
@@ -99,7 +98,6 @@
 	void setNamespace(Namespace value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Specification</b></em>' containment reference.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DirectedRelationship.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DirectedRelationship.java
index 24266c7..8b54005 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DirectedRelationship.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DirectedRelationship.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DirectedRelationship.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: DirectedRelationship.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -63,7 +63,6 @@
 	EList getSources();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Target</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.Element}.
@@ -84,5 +83,4 @@
 	EList getTargets();
 
 
-
 } // DirectedRelationship
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DurationObservationAction.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DurationObservationAction.java
index c656b4c..4bf8f30 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DurationObservationAction.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/DurationObservationAction.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DurationObservationAction.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: DurationObservationAction.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -64,7 +64,6 @@
 	EList getDurations();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Duration} with the specified '<em><b>Name</b></em>' from the '<em><b>Duration</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Element.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Element.java
index 01b3fec..e26345e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Element.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Element.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Element.java,v 1.17 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Element.java,v 1.18 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -73,7 +73,6 @@
 	EList getOwnedElements();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Owner</b></em>' reference.
 	 * It is bidirectional and its opposite is '{@link org.eclipse.uml2.Element#getOwnedElements <em>Owned Element</em>}'.
@@ -95,7 +94,6 @@
 	Element getOwner();
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Owned Comment</b></em>' containment reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.Comment}.
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Feature.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Feature.java
index 097f2dc..029a90c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Feature.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Feature.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Feature.java,v 1.11 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Feature.java,v 1.12 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -96,7 +96,6 @@
 	EList getFeaturingClassifiers();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Classifier} with the specified '<em><b>Name</b></em>' from the '<em><b>Featuring Classifier</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/InterruptibleActivityRegion.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/InterruptibleActivityRegion.java
index 01cfc56..5f57ea3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/InterruptibleActivityRegion.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/InterruptibleActivityRegion.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InterruptibleActivityRegion.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: InterruptibleActivityRegion.java,v 1.10 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -95,7 +95,6 @@
 	EList getContainedNodes();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityNode} with the specified '<em><b>Name</b></em>' from the '<em><b>Contained Node</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/NamedElement.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/NamedElement.java
index 0a7ed00..41e3da3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/NamedElement.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/NamedElement.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: NamedElement.java,v 1.15 2005/11/04 22:23:04 khussey Exp $
+ * $Id: NamedElement.java,v 1.16 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -316,7 +316,6 @@
 	Namespace getNamespace();
 
 
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Namespace.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Namespace.java
index 90df054..ff6cb94 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Namespace.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Namespace.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Namespace.java,v 1.13 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Namespace.java,v 1.14 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -72,7 +72,6 @@
 	EList getMembers();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.NamedElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Member</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -368,7 +367,6 @@
 	EList getOwnedMembers();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.NamedElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Owned Member</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Node.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Node.java
index de641a0..dc11912 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Node.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Node.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Node.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Node.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -61,7 +61,6 @@
 	EList getNestedNodes();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Node} with the specified '<em><b>Name</b></em>' from the '<em><b>Nested Node</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Package.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Package.java
index 3a311c3..92dbf9f 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Package.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Package.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Package.java,v 1.19 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Package.java,v 1.20 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -159,7 +159,6 @@
 	EList getOwnedMembers();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.PackageableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Owned Member</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/PackageableElement.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/PackageableElement.java
index 5808e15..a359366 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/PackageableElement.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/PackageableElement.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PackageableElement.java,v 1.8 2005/11/04 22:23:04 khussey Exp $
+ * $Id: PackageableElement.java,v 1.9 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -74,5 +74,4 @@
 	void setPackageableElement_visibility(VisibilityKind value);
 
 
-
 } // PackageableElement
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/RedefinableElement.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/RedefinableElement.java
index 011ad79..5e8cc90 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/RedefinableElement.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/RedefinableElement.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RedefinableElement.java,v 1.14 2005/11/04 22:23:04 khussey Exp $
+ * $Id: RedefinableElement.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -97,7 +97,6 @@
 	EList getRedefinitionContexts();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.Classifier} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefinition Context</b></em>' reference list.
 	 * <!-- begin-user-doc -->
@@ -153,7 +152,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.RedefinableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Region.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Region.java
index 4b92322..ba06629 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Region.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Region.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Region.java,v 1.8 2005/11/04 22:23:05 khussey Exp $
+ * $Id: Region.java,v 1.9 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -221,7 +221,6 @@
 	void setExtendedRegion(Region value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Redefined Element</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.RedefinableElement}.
@@ -238,7 +237,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.RedefinableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Relationship.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Relationship.java
index 0e8eef2..7877e37 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Relationship.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Relationship.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Relationship.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Relationship.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -62,5 +62,4 @@
 	EList getRelatedElements();
 
 
-
 } // Relationship
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/SendObjectAction.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/SendObjectAction.java
index 494bf9c..ac4e3b9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/SendObjectAction.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/SendObjectAction.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SendObjectAction.java,v 1.8 2005/11/04 22:23:04 khussey Exp $
+ * $Id: SendObjectAction.java,v 1.9 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -118,7 +118,6 @@
 	void setRequest(InputPin value);
 
 
-
 	/**
 	 * Creates a {@link org.eclipse.uml2.InputPin} and sets the '<em><b>Request</b></em>' containment reference.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/State.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/State.java
index 626b369..ffb7066 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/State.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/State.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: State.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: State.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -220,7 +220,6 @@
 	void setRedefinedState(State value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Deferrable Trigger</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.Trigger}.
@@ -512,7 +511,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.RedefinableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StateMachine.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StateMachine.java
index d377d93..0c0ab6f 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StateMachine.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StateMachine.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StateMachine.java,v 1.8 2005/11/04 22:23:04 khussey Exp $
+ * $Id: StateMachine.java,v 1.9 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -172,7 +172,6 @@
 	void setExtendedStateMachine(StateMachine value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>State Machine redefinition Context</b></em>' container reference.
 	 * It is bidirectional and its opposite is '{@link org.eclipse.uml2.BehavioredClassifier#getOwnedStateMachines <em>Owned State Machine</em>}'.
@@ -186,7 +185,7 @@
 	 * @see #setStateMachine_redefinitionContext(BehavioredClassifier)
 	 * @see org.eclipse.uml2.UML2Package#getStateMachine_StateMachine_redefinitionContext()
 	 * @see org.eclipse.uml2.BehavioredClassifier#getOwnedStateMachines
-	 * @model opposite="ownedStateMachine" volatile="true"
+	 * @model opposite="ownedStateMachine"
 	 * @generated
 	 */
 	BehavioredClassifier getStateMachine_redefinitionContext();
@@ -202,7 +201,6 @@
 	void setStateMachine_redefinitionContext(BehavioredClassifier value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Redefined Element</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.RedefinableElement}.
@@ -219,7 +217,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.RedefinableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredActivityNode.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredActivityNode.java
index 0149cb1..a61165f 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredActivityNode.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredActivityNode.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuredActivityNode.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: StructuredActivityNode.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -141,7 +141,6 @@
 	EList getContainedNodes();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityNode} with the specified '<em><b>Name</b></em>' from the '<em><b>Contained Node</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
@@ -183,7 +182,6 @@
 	EList getContainedEdges();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ActivityEdge} with the specified '<em><b>Name</b></em>' from the '<em><b>Contained Edge</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredClassifier.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredClassifier.java
index 831b6e1..703d829 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredClassifier.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/StructuredClassifier.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuredClassifier.java,v 1.10 2005/11/04 22:23:04 khussey Exp $
+ * $Id: StructuredClassifier.java,v 1.11 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -150,7 +150,6 @@
 	EList getRoles();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.ConnectableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Role</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/TimeObservationAction.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/TimeObservationAction.java
index d4669a4..0d62500 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/TimeObservationAction.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/TimeObservationAction.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TimeObservationAction.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: TimeObservationAction.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -64,7 +64,6 @@
 	EList getNows();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.TimeExpression} with the specified '<em><b>Name</b></em>' from the '<em><b>Now</b></em>' containment reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Transition.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Transition.java
index ac14e2f..74f2cd0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Transition.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Transition.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Transition.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Transition.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -200,7 +200,6 @@
 	void setRedefinedTransition(Transition value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Trigger</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.Trigger}.
@@ -351,7 +350,6 @@
 	EList getRedefinedElements();
 
 
-
 	/**
 	 * Retrieves the {@link org.eclipse.uml2.RedefinableElement} with the specified '<em><b>Name</b></em>' from the '<em><b>Redefined Element</b></em>' reference list.
 	 * <!-- begin-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Vertex.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Vertex.java
index 7b0cc2d..17e0148 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Vertex.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/Vertex.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: Vertex.java,v 1.9 2005/11/04 22:23:04 khussey Exp $
+ * $Id: Vertex.java,v 1.10 2005/11/09 22:53:10 khussey Exp $
  */
 package org.eclipse.uml2;
 
@@ -72,7 +72,6 @@
 	void setContainer(Region value);
 
 
-
 	/**
 	 * Returns the value of the '<em><b>Outgoing</b></em>' reference list.
 	 * The list contents are of type {@link org.eclipse.uml2.Transition}.
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AbstractionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AbstractionImpl.java
index ce0d710..a4ac635 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AbstractionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AbstractionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AbstractionImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: AbstractionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,6 +102,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -391,7 +392,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ABSTRACTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -410,7 +411,7 @@
 			case UML2Package.ABSTRACTION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ABSTRACTION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ABSTRACTION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ABSTRACTION__NAME_EXPRESSION:
@@ -438,12 +439,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ABSTRACTION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //AbstractionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptCallActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptCallActionImpl.java
index ebb09fb..f4e4e6e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptCallActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptCallActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AcceptCallActionImpl.java,v 1.14 2005/11/04 22:23:02 khussey Exp $
+ * $Id: AcceptCallActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -104,6 +104,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -166,14 +167,6 @@
 		return trigger;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetTriggers() {
-		return trigger != null && !trigger.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -195,6 +188,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetTriggers() {
+		return trigger != null && !trigger.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ACCEPT_CALL_ACTION__EANNOTATIONS:
@@ -503,7 +505,7 @@
 			case UML2Package.ACCEPT_CALL_ACTION__LOCAL_POSTCONDITION:
 				return localPostcondition != null && !localPostcondition.isEmpty();
 			case UML2Package.ACCEPT_CALL_ACTION__TRIGGER:
-				return !getTriggers().isEmpty();
+				return isSetTriggers();
 			case UML2Package.ACCEPT_CALL_ACTION__RESULT:
 				return result != null && !result.isEmpty();
 			case UML2Package.ACCEPT_CALL_ACTION__RETURN_INFORMATION:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptEventActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptEventActionImpl.java
index da2d4e0..977d5a1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptEventActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AcceptEventActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AcceptEventActionImpl.java,v 1.13 2005/11/04 22:23:01 khussey Exp $
+ * $Id: AcceptEventActionImpl.java,v 1.14 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -106,6 +106,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActionImpl.java
index b4dc76a..1a63ca4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActionImpl.java,v 1.16 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ActionImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -184,6 +184,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -220,6 +221,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -245,6 +247,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityEdgeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityEdgeImpl.java
index 856c34e..42de3b0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityEdgeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityEdgeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityEdgeImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ActivityEdgeImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -348,6 +348,7 @@
 		return inGroup;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -370,6 +371,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -453,14 +455,6 @@
 		return redefinedElement;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetRedefinedElements() {
-		return redefinedElement != null && !redefinedElement.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -482,6 +476,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinedElements() {
+		return redefinedElement != null && !redefinedElement.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public StructuredActivityNode getInStructuredNode() {
 		if (eContainerFeatureID != UML2Package.ACTIVITY_EDGE__IN_STRUCTURED_NODE) return null;
 		return (StructuredActivityNode)eContainer;
@@ -684,6 +687,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getActivityEdge_Activity());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityGroupImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityGroupImpl.java
index 0565644..7fece66 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityGroupImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityGroupImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityGroupImpl.java,v 1.14 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ActivityGroupImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -105,6 +105,7 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -117,7 +118,7 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
 	public Activity getActivityGroup_activity() {
 		if (eContainerFeatureID != UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY) return null;
@@ -127,7 +128,7 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
 	public void setActivityGroup_activity(Activity newActivityGroup_activity) {
 		if (newActivityGroup_activity != eContainer || (eContainerFeatureID != UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY && newActivityGroup_activity != null)) {
@@ -143,6 +144,7 @@
 		}
 		else if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY, newActivityGroup_activity, newActivityGroup_activity));
+
 	}
 
 
@@ -188,6 +190,7 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -195,9 +198,8 @@
 	 */
 	protected EList getOwnedElementsHelper(EList ownedElement) {
 		ownedElement.addAll(super.getOwnedElements());
-		EList subgroup = getSubgroups();
-		if (!subgroup.isEmpty()) {
-			for (Iterator i = ((InternalEList) subgroup).basicIterator(); i.hasNext(); ) {
+		if (isSetSubgroups()) {
+			for (Iterator i = ((InternalEList) getSubgroups()).basicIterator(); i.hasNext(); ) {
 				ownedElement.add(i.next());
 			}
 		}
@@ -233,6 +235,7 @@
 			|| isSetSubgroups();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
      * <!-- end-user-doc -->
@@ -260,6 +263,50 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
+		if (featureID >= 0) {
+			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
+				case UML2Package.ACTIVITY_GROUP__EANNOTATIONS:
+					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
+				case UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY, msgs);
+				default:
+					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
+			}
+		}
+		if (eContainer != null)
+			msgs = eBasicRemoveFromContainer(msgs);
+		return eBasicSetContainer(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
+		if (featureID >= 0) {
+			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
+				case UML2Package.ACTIVITY_GROUP__EANNOTATIONS:
+					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
+				case UML2Package.ACTIVITY_GROUP__OWNED_COMMENT:
+					return ((InternalEList)getOwnedComments()).basicRemove(otherEnd, msgs);
+				case UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY, msgs);
+				default:
+					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
+			}
+		}
+		return eBasicSetContainer(null, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
 	public EList getContainedNodes() {
@@ -305,14 +352,21 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetActivity() {
+		return getActivity() != null;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Element basicGetOwner() {
-		ActivityGroup superGroup = basicGetSuperGroup();			
-		if (superGroup != null) {
-			return superGroup;
+		if (isSetSuperGroup()) {
+			return basicGetSuperGroup();
 		}
-		Activity activityGroup_activity = getActivityGroup_activity();			
-		if (activityGroup_activity != null) {
-			return activityGroup_activity;
+		if (isSetActivityGroup_activity()) {
+			return getActivityGroup_activity();
 		}
 		return super.basicGetOwner();
 	}
@@ -328,6 +382,7 @@
 			|| isSetActivityGroup_activity();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -337,26 +392,6 @@
 		return subgroup;
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY:
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.ACTIVITY_GROUP__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityImpl.java
index b575a93..5187a4a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityImpl.java,v 1.29 2005/11/04 22:22:59 khussey Exp $
+ * $Id: ActivityImpl.java,v 1.30 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -79,6 +79,16 @@
 	public static final String copyright = "Copyright (c) IBM Corporation and others."; //$NON-NLS-1$
 
 	/**
+	 * The cached value of the '{@link #getGroups() <em>Group</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroups()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList group = null;
+
+	/**
 	 * The cached value of the '{@link #getNodes() <em>Node</em>}' containment reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -139,16 +149,6 @@
 	protected EList edge = null;
 
 	/**
-	 * The cached value of the '{@link #getGroups() <em>Group</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getGroups()
-	 * @generated NOT
-	 * @ordered
-	 */
-	protected EList group = null;
-
-	/**
 	 * The cached value of the '{@link #getActions() <em>Action</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -355,7 +355,7 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
 	public EList getGroups() {
 		if (group == null) {
@@ -364,6 +364,7 @@
 		return group;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -521,6 +522,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.ACTIVITY__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.ACTIVITY__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.ACTIVITY__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.ACTIVITY__CONTEXT:
@@ -533,6 +536,8 @@
 					return basicSetSpecification((BehavioralFeature)otherEnd, msgs);
 				case UML2Package.ACTIVITY__EDGE:
 					return ((InternalEList)getEdges()).basicAdd(otherEnd, msgs);
+				case UML2Package.ACTIVITY__GROUP:
+					return ((InternalEList)getGroups()).basicAdd(otherEnd, msgs);
 				case UML2Package.ACTIVITY__NODE:
 					return ((InternalEList)getNodes()).basicAdd(otherEnd, msgs);
 				default:
@@ -544,19 +549,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY__GROUP:
-				return ((InternalEList)getGroups()).basicAdd(otherEnd, msgs);
-			case UML2Package.ACTIVITY__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			case UML2Package.ACTIVITY__STRUCTURED_NODE :
-				return ((InternalEList) getStructuredNodes()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -640,15 +632,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY__STRUCTURED_NODE :
-				return ((InternalEList) getStructuredNodes()).basicRemove(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1175,7 +1158,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ACTIVITY__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1194,7 +1177,7 @@
 			case UML2Package.ACTIVITY__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ACTIVITY__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ACTIVITY__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ACTIVITY__NAME_EXPRESSION:
@@ -1224,11 +1207,11 @@
 			case UML2Package.ACTIVITY__FEATURE:
 				return isSetFeatures();
 			case UML2Package.ACTIVITY__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.ACTIVITY__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.ACTIVITY__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.ACTIVITY__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.ACTIVITY__ATTRIBUTE:
@@ -1248,7 +1231,7 @@
 			case UML2Package.ACTIVITY__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.ACTIVITY__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.ACTIVITY__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.ACTIVITY__IMPLEMENTATION:
@@ -1258,7 +1241,7 @@
 			case UML2Package.ACTIVITY__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.ACTIVITY__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.ACTIVITY__PART:
 				return !getParts().isEmpty();
 			case UML2Package.ACTIVITY__ROLE:
@@ -1306,7 +1289,7 @@
 			case UML2Package.ACTIVITY__EDGE:
 				return edge != null && !edge.isEmpty();
 			case UML2Package.ACTIVITY__GROUP:
-				return !getGroups().isEmpty();
+				return group != null && !group.isEmpty();
 			case UML2Package.ACTIVITY__NODE:
 				return node != null && !node.isEmpty();
 			case UML2Package.ACTIVITY__ACTION:
@@ -1321,20 +1304,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ACTIVITY__VISIBILITY:
-				return false;
-			case UML2Package.ACTIVITY__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.ACTIVITY__GROUP:
-				return group != null && !group.isEmpty();
-			case UML2Package.ACTIVITY__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1367,9 +1336,8 @@
 		if (eIsSet(UML2Package.eINSTANCE.getActivity_Edge())) {
 			ownedElement.addAll(getEdges());
 		}
-		EList group = getGroups();
-		if (!group.isEmpty()) {
-			ownedElement.addAll(group);
+		if (eIsSet(UML2Package.eINSTANCE.getActivity_Group())) {
+			ownedElement.addAll(getGroups());
 		}
 		if (eIsSet(UML2Package.eINSTANCE.getActivity_Node())) {
 			ownedElement.addAll(getNodes());
@@ -1389,4 +1357,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getActivity_Node());
 	}
 
+
 } //ActivityImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityNodeImpl.java
index e6a2a11..342fec7 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityNodeImpl.java,v 1.13 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ActivityNodeImpl.java,v 1.14 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -221,6 +221,7 @@
 		return inGroup;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -277,14 +278,6 @@
 		return redefinedElement;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetRedefinedElements() {
-		return redefinedElement != null && !redefinedElement.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -306,6 +299,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinedElements() {
+		return redefinedElement != null && !redefinedElement.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public StructuredActivityNode getInStructuredNode() {
 		if (eContainerFeatureID != UML2Package.ACTIVITY_NODE__IN_STRUCTURED_NODE) return null;
 		return (StructuredActivityNode)eContainer;
@@ -398,6 +400,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getActivityNode_Activity());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityPartitionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityPartitionImpl.java
index eb35605..eb0777b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityPartitionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ActivityPartitionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ActivityPartitionImpl.java,v 1.14 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ActivityPartitionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -266,14 +266,6 @@
 		return containedEdge;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetContainedEdges() {
-		return containedEdge != null && !containedEdge.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -295,11 +287,8 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getContainedNodes() {
-		if (containedNode == null) {
-			containedNode = new EObjectWithInverseResolvingEList.ManyInverse(ActivityNode.class, this, UML2Package.ACTIVITY_PARTITION__CONTAINED_NODE, UML2Package.ACTIVITY_NODE__IN_PARTITION);
-		}
-		return containedNode;
+	public boolean isSetContainedEdges() {
+		return containedEdge != null && !containedEdge.isEmpty();
 	}
 
 	/**
@@ -307,10 +296,14 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetContainedNodes() {
-		return containedNode != null && !containedNode.isEmpty();
+	public EList getContainedNodes() {
+		if (containedNode == null) {
+			containedNode = new EObjectWithInverseResolvingEList.ManyInverse(ActivityNode.class, this, UML2Package.ACTIVITY_PARTITION__CONTAINED_NODE, UML2Package.ACTIVITY_NODE__IN_PARTITION);
+		}
+		return containedNode;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -331,11 +324,8 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getSubgroups() {
-		if (subgroup == null) {
-			subgroup = new EObjectContainmentWithInverseEList(ActivityPartition.class, this, UML2Package.ACTIVITY_PARTITION__SUBGROUP, UML2Package.ACTIVITY_PARTITION__SUPER_PARTITION);
-		}
-		return subgroup;
+	public boolean isSetContainedNodes() {
+		return containedNode != null && !containedNode.isEmpty();
 	}
 
 	/**
@@ -343,10 +333,14 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetSubgroups() {
-		return subgroup != null && !subgroup.isEmpty();
+	public EList getSubgroups() {
+		if (subgroup == null) {
+			subgroup = new EObjectContainmentWithInverseEList(ActivityPartition.class, this, UML2Package.ACTIVITY_PARTITION__SUBGROUP, UML2Package.ACTIVITY_PARTITION__SUPER_PARTITION);
+		}
+		return subgroup;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -367,6 +361,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetSubgroups() {
+		return subgroup != null && !subgroup.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public EList getOwnedElements() {
 		if (ownedElement == null) {
 			ownedElement = new DerivedUnionEObjectEList(Element.class, this, UML2Package.ACTIVITY_PARTITION__OWNED_ELEMENT, new EStructuralFeature[] {UML2Package.eINSTANCE.getElement_OwnedComment(), UML2Package.eINSTANCE.getTemplateableElement_TemplateBinding(), UML2Package.eINSTANCE.getTemplateableElement_OwnedTemplateSignature(), UML2Package.eINSTANCE.getNamedElement_NameExpression(), UML2Package.eINSTANCE.getActivityPartition_Subgroup()});
@@ -374,6 +377,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -510,14 +514,21 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetActivity() {
+		return getActivity() != null;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Element basicGetOwner() {
-		ActivityGroup superGroup = basicGetSuperGroup();			
-		if (superGroup != null) {
-			return superGroup;
+		if (isSetSuperGroup()) {
+			return basicGetSuperGroup();
 		}
-		Activity activityGroup_activity = getActivityGroup_activity();			
-		if (activityGroup_activity != null) {
-			return activityGroup_activity;
+		if (isSetActivityGroup_activity()) {
+			return getActivityGroup_activity();
 		}
 		return super.basicGetOwner();
 	}
@@ -533,6 +544,7 @@
 			|| isSetActivityGroup_activity();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -565,6 +577,7 @@
 		return eIsSet(UML2Package.eINSTANCE.getActivityPartition_SuperPartition());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -583,6 +596,10 @@
 					return basicSetOwnedTemplateSignature((TemplateSignature)otherEnd, msgs);
 				case UML2Package.ACTIVITY_PARTITION__CLIENT_DEPENDENCY:
 					return ((InternalEList)getClientDependencies()).basicAdd(otherEnd, msgs);
+				case UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.ACTIVITY_PARTITION__CONTAINED_EDGE:
 					return ((InternalEList)getContainedEdges()).basicAdd(otherEnd, msgs);
 				case UML2Package.ACTIVITY_PARTITION__CONTAINED_NODE:
@@ -602,17 +619,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY:
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -633,6 +639,8 @@
 					return ((InternalEList)getClientDependencies()).basicRemove(otherEnd, msgs);
 				case UML2Package.ACTIVITY_PARTITION__NAME_EXPRESSION:
 					return basicSetNameExpression(null, msgs);
+				case UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.ACTIVITY_PARTITION__CONTAINED_EDGE:
 					return ((InternalEList)getContainedEdges()).basicRemove(otherEnd, msgs);
 				case UML2Package.ACTIVITY_PARTITION__CONTAINED_NODE:
@@ -648,15 +656,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.ACTIVITY_PARTITION__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddStructuralFeatureValueActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddStructuralFeatureValueActionImpl.java
index a32222c..8aaa772 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddStructuralFeatureValueActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddStructuralFeatureValueActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AddStructuralFeatureValueActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: AddStructuralFeatureValueActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -123,6 +123,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddVariableValueActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddVariableValueActionImpl.java
index 419b94e..1f1e2db 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddVariableValueActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AddVariableValueActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AddVariableValueActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: AddVariableValueActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -123,6 +123,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ApplyFunctionActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ApplyFunctionActionImpl.java
index fcfd4bb..4117c41 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ApplyFunctionActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ApplyFunctionActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ApplyFunctionActionImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ApplyFunctionActionImpl.java,v 1.15 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -128,6 +128,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -150,6 +151,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ArtifactImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ArtifactImpl.java
index 53d4fa1..74ae98d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ArtifactImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ArtifactImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ArtifactImpl.java,v 1.24 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ArtifactImpl.java,v 1.25 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -170,6 +170,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -192,6 +193,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -883,7 +885,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ARTIFACT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -902,7 +904,7 @@
 			case UML2Package.ARTIFACT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ARTIFACT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ARTIFACT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ARTIFACT__NAME_EXPRESSION:
@@ -969,14 +971,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ARTIFACT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1016,6 +1010,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getArtifact_Manifestation());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1043,6 +1038,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getArtifact_OwnedAttribute());
 	}
 
+
 	// <!-- begin-custom-operations -->
 	
 	private static Method GET_ALL_OPERATIONS = null;
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationClassImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationClassImpl.java
index 0fc001d..c216dd0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationClassImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationClassImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AssociationClassImpl.java,v 1.33 2005/11/04 22:23:02 khussey Exp $
+ * $Id: AssociationClassImpl.java,v 1.34 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -161,6 +161,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -182,6 +183,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -215,6 +217,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getAssociation_OwnedEnd());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -240,6 +243,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getAssociation_MemberEnd());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -434,6 +438,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.ASSOCIATION_CLASS__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.ASSOCIATION_CLASS__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.ASSOCIATION_CLASS__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.ASSOCIATION_CLASS__OWNED_END:
@@ -449,15 +455,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.ASSOCIATION_CLASS__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -943,7 +940,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ASSOCIATION_CLASS__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -962,7 +959,7 @@
 			case UML2Package.ASSOCIATION_CLASS__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ASSOCIATION_CLASS__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ASSOCIATION_CLASS__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ASSOCIATION_CLASS__NAME_EXPRESSION:
@@ -992,11 +989,11 @@
 			case UML2Package.ASSOCIATION_CLASS__FEATURE:
 				return isSetFeatures();
 			case UML2Package.ASSOCIATION_CLASS__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.ASSOCIATION_CLASS__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.ASSOCIATION_CLASS__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.ASSOCIATION_CLASS__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.ASSOCIATION_CLASS__ATTRIBUTE:
@@ -1016,7 +1013,7 @@
 			case UML2Package.ASSOCIATION_CLASS__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.ASSOCIATION_CLASS__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.ASSOCIATION_CLASS__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.ASSOCIATION_CLASS__IMPLEMENTATION:
@@ -1026,7 +1023,7 @@
 			case UML2Package.ASSOCIATION_CLASS__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.ASSOCIATION_CLASS__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.ASSOCIATION_CLASS__PART:
 				return !getParts().isEmpty();
 			case UML2Package.ASSOCIATION_CLASS__ROLE:
@@ -1061,18 +1058,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ASSOCIATION_CLASS__VISIBILITY:
-				return false;
-			case UML2Package.ASSOCIATION_CLASS__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.ASSOCIATION_CLASS__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationImpl.java
index ccef779..0cef809 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/AssociationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: AssociationImpl.java,v 1.26 2005/11/04 22:23:02 khussey Exp $
+ * $Id: AssociationImpl.java,v 1.27 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -308,6 +308,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -329,6 +330,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -362,6 +364,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getAssociation_OwnedEnd());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -387,6 +390,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getAssociation_MemberEnd());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -791,7 +795,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ASSOCIATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -810,7 +814,7 @@
 			case UML2Package.ASSOCIATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ASSOCIATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ASSOCIATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ASSOCIATION__NAME_EXPRESSION:
@@ -877,14 +881,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ASSOCIATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehaviorImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehaviorImpl.java
index 84ffa85..fd795b4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehaviorImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehaviorImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: BehaviorImpl.java,v 1.29 2005/11/04 22:23:00 khussey Exp $
+ * $Id: BehaviorImpl.java,v 1.30 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -645,6 +645,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.BEHAVIOR__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.BEHAVIOR__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.BEHAVIOR__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.BEHAVIOR__CONTEXT:
@@ -664,15 +666,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.BEHAVIOR__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1225,7 +1218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.BEHAVIOR__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1244,7 +1237,7 @@
 			case UML2Package.BEHAVIOR__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.BEHAVIOR__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.BEHAVIOR__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.BEHAVIOR__NAME_EXPRESSION:
@@ -1274,11 +1267,11 @@
 			case UML2Package.BEHAVIOR__FEATURE:
 				return isSetFeatures();
 			case UML2Package.BEHAVIOR__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.BEHAVIOR__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.BEHAVIOR__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.BEHAVIOR__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.BEHAVIOR__ATTRIBUTE:
@@ -1298,7 +1291,7 @@
 			case UML2Package.BEHAVIOR__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.BEHAVIOR__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.BEHAVIOR__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.BEHAVIOR__IMPLEMENTATION:
@@ -1308,7 +1301,7 @@
 			case UML2Package.BEHAVIOR__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.BEHAVIOR__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.BEHAVIOR__PART:
 				return !getParts().isEmpty();
 			case UML2Package.BEHAVIOR__ROLE:
@@ -1353,18 +1346,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.BEHAVIOR__VISIBILITY:
-				return false;
-			case UML2Package.BEHAVIOR__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.BEHAVIOR__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1406,6 +1387,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getBehavior_RedefinedBehavior());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1429,4 +1411,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getBehavior_Parameter());
 	}
 
+
 } //BehaviorImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioralFeatureImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioralFeatureImpl.java
index 8103581..803f2c5 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioralFeatureImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioralFeatureImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: BehavioralFeatureImpl.java,v 1.18 2005/11/04 22:22:59 khussey Exp $
+ * $Id: BehavioralFeatureImpl.java,v 1.19 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -294,6 +294,7 @@
 		return redefinitionContext;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -362,6 +363,7 @@
 		return featuringClassifier;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -462,6 +464,7 @@
 		return parameter;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -494,7 +497,7 @@
 	 */
 	protected EList getMembersHelper(EList member) {
 		super.getMembersHelper(member);
-		if (eIsSet(UML2Package.eINSTANCE.getBehavioralFeature_Parameter())) {
+		if (isSetParameters()) {
 			for (Iterator i = ((InternalEList) getParameters()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
@@ -512,6 +515,7 @@
 			|| isSetParameters();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -539,6 +543,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getBehavioralFeature_ReturnResult());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -760,6 +765,7 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioredClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioredClassifierImpl.java
index e25da2c..9c98857 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioredClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/BehavioredClassifierImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: BehavioredClassifierImpl.java,v 1.23 2005/11/04 22:23:01 khussey Exp $
+ * $Id: BehavioredClassifierImpl.java,v 1.24 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,7 +125,7 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @see #getOwnedStateMachines()
-	 * @generated NOT
+	 * @generated
 	 * @ordered
 	 */
 	protected EList ownedStateMachine = null;
@@ -163,6 +163,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetOwnedBehaviors() {
+		return ownedBehavior != null && !ownedBehavior.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
     public Behavior getOwnedBehavior(String name) {
@@ -317,7 +326,7 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
 	public EList getOwnedStateMachines() {
 		if (ownedStateMachine == null) {
@@ -436,6 +445,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.BEHAVIORED_CLASSIFIER__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.BEHAVIORED_CLASSIFIER__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				default:
 					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
 			}
@@ -445,15 +456,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.BEHAVIORED_CLASSIFIER__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -823,7 +825,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.BEHAVIORED_CLASSIFIER__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -842,7 +844,7 @@
 			case UML2Package.BEHAVIORED_CLASSIFIER__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.BEHAVIORED_CLASSIFIER__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.BEHAVIORED_CLASSIFIER__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.BEHAVIORED_CLASSIFIER__NAME_EXPRESSION:
@@ -896,7 +898,7 @@
 			case UML2Package.BEHAVIORED_CLASSIFIER__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.BEHAVIORED_CLASSIFIER__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.BEHAVIORED_CLASSIFIER__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.BEHAVIORED_CLASSIFIER__IMPLEMENTATION:
@@ -910,16 +912,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.BEHAVIORED_CLASSIFIER__VISIBILITY:
-				return false;
-			case UML2Package.BEHAVIORED_CLASSIFIER__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -927,9 +919,8 @@
 	 */
 	protected EList getOwnedMembersHelper(EList ownedMember) {
 		super.getOwnedMembersHelper(ownedMember);
-		EList ownedBehavior = getOwnedBehaviors();
-		if (!ownedBehavior.isEmpty()) {
-			ownedMember.addAll(ownedBehavior);
+		if (isSetOwnedBehaviors()) {
+			ownedMember.addAll(getOwnedBehaviors());
 		}
 		if (eIsSet(UML2Package.eINSTANCE.getBehavioredClassifier_OwnedTrigger())) {
 			ownedMember.addAll(getOwnedTriggers());
@@ -944,10 +935,11 @@
 	 */
 	public boolean isSetOwnedMembers() {
 		return super.isSetOwnedMembers()
-			|| eIsSet(UML2Package.eINSTANCE.getBehavioredClassifier_OwnedBehavior())
+			|| isSetOwnedBehaviors()
 			|| eIsSet(UML2Package.eINSTANCE.getBehavioredClassifier_OwnedTrigger());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -971,6 +963,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getBehavioredClassifier_Implementation());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	private static Method GET_IMPLEMENTED_INTERFACES = null;
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallActionImpl.java
index a718da9..14cc81d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CallActionImpl.java,v 1.14 2005/11/04 22:23:02 khussey Exp $
+ * $Id: CallActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -126,6 +126,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallOperationActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallOperationActionImpl.java
index 2c2d2e5..c0bea8e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallOperationActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CallOperationActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CallOperationActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: CallOperationActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -114,6 +114,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ChangeTriggerImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ChangeTriggerImpl.java
index ca26690..f285711 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ChangeTriggerImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ChangeTriggerImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ChangeTriggerImpl.java,v 1.13 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ChangeTriggerImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -99,6 +99,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassImpl.java
index 036a066..3d54067 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ClassImpl.java,v 1.37 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ClassImpl.java,v 1.38 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -224,15 +224,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetOwnedAttributes() {
-		return ownedAttribute != null && !ownedAttribute.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public Property getOwnedAttribute(String name) {
 		for (Iterator i = getOwnedAttributes().iterator(); i.hasNext(); ) {
 			Property ownedAttribute = (Property) i.next();
@@ -248,6 +239,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetOwnedAttributes() {
+		return ownedAttribute != null && !ownedAttribute.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Property createOwnedAttribute(EClass eClass) {
 		Property newOwnedAttribute = (Property) eClass.getEPackage().getEFactoryInstance().create(eClass);
 		if (eNotificationRequired()) {
@@ -327,13 +327,14 @@
 		return role;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public boolean isSetRoles() {
-		return eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_OwnedAttribute());
+		return isSetOwnedAttributes();
 	}
 
 	/**
@@ -363,6 +364,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -385,6 +387,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -405,7 +408,7 @@
 	 */
 	protected EList getOwnedMembersHelper(EList ownedMember) {
 		super.getOwnedMembersHelper(ownedMember);
-		if (eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_OwnedAttribute())) {
+		if (isSetOwnedAttributes()) {
 			ownedMember.addAll(getOwnedAttributes());
 		}
 		if (eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_OwnedConnector())) {
@@ -441,6 +444,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getClass_OwnedReception());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -448,7 +452,7 @@
 	 */
 	protected EList getMembersHelper(EList member) {
 		super.getMembersHelper(member);
-		if (eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_Role())) {
+		if (isSetRoles()) {
 			for (Iterator i = ((InternalEList) getRoles()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
@@ -466,6 +470,7 @@
 			|| isSetRoles();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -694,15 +699,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetSuperClasses() {
-		return !getSuperClasses().isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public org.eclipse.uml2.Class getSuperClass(String name) {
 		for (Iterator i = getSuperClasses().iterator(); i.hasNext(); ) {
 			org.eclipse.uml2.Class superClass = (org.eclipse.uml2.Class) i.next();
@@ -716,6 +712,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetSuperClasses() {
+		return !getSuperClasses().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
 	public EList getExtensions() {
@@ -886,6 +891,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -910,6 +916,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetGenerals() {
+		return !getGenerals().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -949,6 +964,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.CLASS__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.CLASS__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.CLASS__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				default:
@@ -960,15 +977,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.CLASS__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1420,7 +1428,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.CLASS__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1439,7 +1447,7 @@
 			case UML2Package.CLASS__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.CLASS__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.CLASS__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.CLASS__NAME_EXPRESSION:
@@ -1469,11 +1477,11 @@
 			case UML2Package.CLASS__FEATURE:
 				return isSetFeatures();
 			case UML2Package.CLASS__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.CLASS__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.CLASS__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.CLASS__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.CLASS__ATTRIBUTE:
@@ -1493,7 +1501,7 @@
 			case UML2Package.CLASS__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.CLASS__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.CLASS__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.CLASS__IMPLEMENTATION:
@@ -1503,7 +1511,7 @@
 			case UML2Package.CLASS__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.CLASS__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.CLASS__PART:
 				return !getParts().isEmpty();
 			case UML2Package.CLASS__ROLE:
@@ -1528,18 +1536,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.CLASS__VISIBILITY:
-				return false;
-			case UML2Package.CLASS__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.CLASS__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassifierImpl.java
index a311669..67f88a5 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClassifierImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ClassifierImpl.java,v 1.33 2005/11/08 18:26:42 khussey Exp $
+ * $Id: ClassifierImpl.java,v 1.34 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -559,6 +559,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -590,7 +591,7 @@
 	 */
 	protected EList getMembersHelper(EList member) {
 		super.getMembersHelper(member);
-		if (eIsSet(UML2Package.eINSTANCE.getClassifier_Feature())) {
+		if (isSetFeatures()) {
 			for (Iterator i = ((InternalEList) getFeatures()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
@@ -615,6 +616,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getClassifier_InheritedMember());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -646,6 +648,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getClassifier_Occurrence());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -789,6 +792,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -836,6 +840,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getClassifier_OwnedUseCase());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1140,6 +1145,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1164,6 +1170,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
+	public boolean isSetVisibility() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
 	public boolean conformsTo(Type other) {
 		return conformsTo((Classifier) other);
 	}
@@ -1209,6 +1224,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getType_Package());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1426,6 +1442,7 @@
 		return eIsSet(UML2Package.eINSTANCE.getClassifier_RedefinedClassifier());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1837,7 +1854,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.CLASSIFIER__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1856,7 +1873,7 @@
 			case UML2Package.CLASSIFIER__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.CLASSIFIER__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.CLASSIFIER__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.CLASSIFIER__NAME_EXPRESSION:
@@ -1913,14 +1930,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.CLASSIFIER__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClearAssociationActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClearAssociationActionImpl.java
index c8f836d..d987958 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClearAssociationActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ClearAssociationActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ClearAssociationActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ClearAssociationActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -112,6 +112,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationImpl.java
index 3560aa7..976124e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CollaborationImpl.java,v 1.25 2005/11/04 22:23:02 khussey Exp $
+ * $Id: CollaborationImpl.java,v 1.26 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -263,6 +263,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -285,6 +286,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -322,6 +324,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_OwnedConnector());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -329,7 +332,7 @@
 	 */
 	protected EList getMembersHelper(EList member) {
 		super.getMembersHelper(member);
-		if (eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_Role())) {
+		if (isSetRoles()) {
 			for (Iterator i = ((InternalEList) getRoles()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
@@ -347,6 +350,7 @@
 			|| isSetRoles();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -444,6 +448,7 @@
 		return role;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -454,15 +459,6 @@
 			|| eIsSet(UML2Package.eINSTANCE.getCollaboration_CollaborationRole());
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.COLLABORATION__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -867,7 +863,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.COLLABORATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -886,7 +882,7 @@
 			case UML2Package.COLLABORATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.COLLABORATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.COLLABORATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.COLLABORATION__NAME_EXPRESSION:
@@ -940,7 +936,7 @@
 			case UML2Package.COLLABORATION__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.COLLABORATION__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.COLLABORATION__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.COLLABORATION__IMPLEMENTATION:
@@ -963,16 +959,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.COLLABORATION__VISIBILITY:
-				return false;
-			case UML2Package.COLLABORATION__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationOccurrenceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationOccurrenceImpl.java
index c6d6efd..9851c2a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationOccurrenceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CollaborationOccurrenceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CollaborationOccurrenceImpl.java,v 1.12 2005/11/04 22:23:00 khussey Exp $
+ * $Id: CollaborationOccurrenceImpl.java,v 1.13 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -114,6 +114,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CombinedFragmentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CombinedFragmentImpl.java
index da5b6a5..44a9341 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CombinedFragmentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CombinedFragmentImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CombinedFragmentImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: CombinedFragmentImpl.java,v 1.13 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -137,6 +137,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommentImpl.java
index 0b0aac9..457f8a4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommentImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CommentImpl.java,v 1.12 2005/11/04 22:23:00 khussey Exp $
+ * $Id: CommentImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -131,6 +131,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommunicationPathImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommunicationPathImpl.java
index 104e87f..d0130c6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommunicationPathImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CommunicationPathImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CommunicationPathImpl.java,v 1.20 2005/11/04 22:22:59 khussey Exp $
+ * $Id: CommunicationPathImpl.java,v 1.21 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.CommunicationPath;
 import org.eclipse.uml2.UML2Package;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.COMMUNICATION_PATH__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //CommunicationPathImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ComponentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ComponentImpl.java
index 220e75f..d5659c5 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ComponentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ComponentImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ComponentImpl.java,v 1.31 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ComponentImpl.java,v 1.32 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -315,14 +315,6 @@
 		return ownedMember;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetOwnedMembers() {
-		return ownedMember != null && !ownedMember.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -342,6 +334,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetOwnedMembers() {
+		return ownedMember != null && !ownedMember.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
 	public PackageableElement createOwnedMember(EClass eClass) {
@@ -410,6 +411,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.COMPONENT__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.COMPONENT__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.COMPONENT__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.COMPONENT__REALIZATION:
@@ -423,15 +426,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.COMPONENT__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -917,7 +911,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.COMPONENT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -936,7 +930,7 @@
 			case UML2Package.COMPONENT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.COMPONENT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.COMPONENT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.COMPONENT__NAME_EXPRESSION:
@@ -966,11 +960,11 @@
 			case UML2Package.COMPONENT__FEATURE:
 				return isSetFeatures();
 			case UML2Package.COMPONENT__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.COMPONENT__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.COMPONENT__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.COMPONENT__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.COMPONENT__ATTRIBUTE:
@@ -990,7 +984,7 @@
 			case UML2Package.COMPONENT__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.COMPONENT__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.COMPONENT__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.COMPONENT__IMPLEMENTATION:
@@ -1000,7 +994,7 @@
 			case UML2Package.COMPONENT__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.COMPONENT__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.COMPONENT__PART:
 				return !getParts().isEmpty();
 			case UML2Package.COMPONENT__ROLE:
@@ -1035,18 +1029,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.COMPONENT__VISIBILITY:
-				return false;
-			case UML2Package.COMPONENT__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.COMPONENT__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConditionalNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConditionalNodeImpl.java
index 3a1b2ba..1b9e76d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConditionalNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConditionalNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ConditionalNodeImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ConditionalNodeImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -157,6 +157,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -356,6 +357,8 @@
 					return ((InternalEList)getElementImports()).basicRemove(otherEnd, msgs);
 				case UML2Package.CONDITIONAL_NODE__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicRemove(otherEnd, msgs);
+				case UML2Package.CONDITIONAL_NODE__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.CONDITIONAL_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.CONDITIONAL_NODE__VARIABLE:
 					return ((InternalEList)getVariables()).basicRemove(otherEnd, msgs);
 				case UML2Package.CONDITIONAL_NODE__CONTAINED_NODE:
@@ -373,15 +376,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.CONDITIONAL_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.CONDITIONAL_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -720,7 +714,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.CONDITIONAL_NODE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -755,7 +749,7 @@
 			case UML2Package.CONDITIONAL_NODE__IN_GROUP:
 				return isSetInGroups();
 			case UML2Package.CONDITIONAL_NODE__ACTIVITY:
-				return getActivity() != null;
+				return isSetActivity();
 			case UML2Package.CONDITIONAL_NODE__REDEFINED_ELEMENT:
 				return isSetRedefinedElements();
 			case UML2Package.CONDITIONAL_NODE__IN_STRUCTURED_NODE:
@@ -812,16 +806,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.CONDITIONAL_NODE__ACTIVITY:
-				return false;
-			case UML2Package.CONDITIONAL_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -863,4 +847,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getConditionalNode_Clause());
 	}
 
+
 } //ConditionalNodeImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectableElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectableElementImpl.java
index a020875..151d692 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectableElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectableElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ConnectableElementImpl.java,v 1.11 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ConnectableElementImpl.java,v 1.12 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -235,6 +235,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectorImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectorImpl.java
index 48773ed..79dc800 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectorImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConnectorImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ConnectorImpl.java,v 1.13 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ConnectorImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -160,6 +160,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -624,4 +625,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getConnector_RedefinedConnector());
 	}
 
+
 } //ConnectorImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConstraintImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConstraintImpl.java
index 6d903e3..3dcc57f 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConstraintImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ConstraintImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ConstraintImpl.java,v 1.17 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ConstraintImpl.java,v 1.18 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -119,6 +119,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -148,15 +149,15 @@
 		return isSetNamespace();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public Namespace basicGetContext() {
-		Namespace namespace = getNamespace();			
-		if (namespace != null) {
-			return namespace;
+		if (isSetNamespace()) {
+			return getNamespace();
 		}
 		return null;
 	}
@@ -193,6 +194,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -543,7 +545,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.CONSTRAINT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -562,7 +564,7 @@
 			case UML2Package.CONSTRAINT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.CONSTRAINT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.CONSTRAINT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.CONSTRAINT__NAME_EXPRESSION:
@@ -586,12 +588,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.CONSTRAINT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ConstraintImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkActionImpl.java
index b923a45..8488c33 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CreateLinkActionImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: CreateLinkActionImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -74,15 +74,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetEndData() {
-		return endData != null && !endData.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 * @deprecated Use #createEndData() instead.
 	 */
@@ -114,6 +105,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetEndData() {
+		return endData != null && !endData.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.CREATE_LINK_ACTION__EANNOTATIONS:
@@ -243,7 +243,7 @@
 			case UML2Package.CREATE_LINK_ACTION__LOCAL_POSTCONDITION:
 				return localPostcondition != null && !localPostcondition.isEmpty();
 			case UML2Package.CREATE_LINK_ACTION__END_DATA:
-				return !getEndData().isEmpty();
+				return isSetEndData();
 		}
 		return eDynamicIsSet(eFeature);
 	}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkObjectActionImpl.java
index 5a3cf4c..abc75e6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateLinkObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CreateLinkObjectActionImpl.java,v 1.16 2005/11/04 22:23:01 khussey Exp $
+ * $Id: CreateLinkObjectActionImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -105,6 +105,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -201,15 +202,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetEndData() {
-		return endData != null && !endData.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 * @deprecated Use #createEndData() instead.
 	 */
@@ -241,6 +233,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetEndData() {
+		return endData != null && !endData.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -588,7 +589,7 @@
 			case UML2Package.CREATE_LINK_OBJECT_ACTION__LOCAL_POSTCONDITION:
 				return localPostcondition != null && !localPostcondition.isEmpty();
 			case UML2Package.CREATE_LINK_OBJECT_ACTION__END_DATA:
-				return !getEndData().isEmpty();
+				return isSetEndData();
 			case UML2Package.CREATE_LINK_OBJECT_ACTION__RESULT:
 				return result != null;
 		}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateObjectActionImpl.java
index ce5c1ad..40f085e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/CreateObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: CreateObjectActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: CreateObjectActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -113,6 +113,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DataTypeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DataTypeImpl.java
index db8fcf7..3cff824 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DataTypeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DataTypeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DataTypeImpl.java,v 1.25 2005/11/04 22:23:01 khussey Exp $
+ * $Id: DataTypeImpl.java,v 1.26 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,6 +125,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -147,6 +148,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -671,7 +673,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DATA_TYPE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -690,7 +692,7 @@
 			case UML2Package.DATA_TYPE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.DATA_TYPE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.DATA_TYPE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.DATA_TYPE__NAME_EXPRESSION:
@@ -752,14 +754,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DATA_TYPE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -787,6 +781,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getDataType_OwnedOperation());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DependencyImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DependencyImpl.java
index 433084e..fc9c632 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DependencyImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DependencyImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DependencyImpl.java,v 1.16 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DependencyImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -145,6 +145,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -485,7 +486,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DEPENDENCY__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -504,7 +505,7 @@
 			case UML2Package.DEPENDENCY__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.DEPENDENCY__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.DEPENDENCY__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.DEPENDENCY__NAME_EXPRESSION:
@@ -529,14 +530,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DEPENDENCY__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentImpl.java
index 2ab3338..026129a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DeploymentImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DeploymentImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -166,6 +166,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -608,7 +609,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DEPLOYMENT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -627,7 +628,7 @@
 			case UML2Package.DEPLOYMENT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.DEPLOYMENT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.DEPLOYMENT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.DEPLOYMENT__NAME_EXPRESSION:
@@ -659,12 +660,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DEPLOYMENT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //DeploymentImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentSpecificationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentSpecificationImpl.java
index a4246ee..b986abd 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentSpecificationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentSpecificationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DeploymentSpecificationImpl.java,v 1.20 2005/11/04 22:23:01 khussey Exp $
+ * $Id: DeploymentSpecificationImpl.java,v 1.21 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -482,7 +482,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DEPLOYMENT_SPECIFICATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -501,7 +501,7 @@
 			case UML2Package.DEPLOYMENT_SPECIFICATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.DEPLOYMENT_SPECIFICATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.DEPLOYMENT_SPECIFICATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.DEPLOYMENT_SPECIFICATION__NAME_EXPRESSION:
@@ -572,14 +572,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DEPLOYMENT_SPECIFICATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentTargetImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentTargetImpl.java
index d137386..a7d821c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentTargetImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeploymentTargetImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DeploymentTargetImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DeploymentTargetImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -110,6 +110,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DestroyObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DestroyObjectActionImpl.java
index 3d39f25..8107e0c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DestroyObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DestroyObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DestroyObjectActionImpl.java,v 1.16 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DestroyObjectActionImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -142,6 +142,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeviceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeviceImpl.java
index bc92e2b..ad0b758 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeviceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DeviceImpl.java
@@ -8,15 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DeviceImpl.java,v 1.25 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DeviceImpl.java,v 1.26 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
-import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.uml2.Device;
 import org.eclipse.uml2.UML2Package;
 
@@ -55,28 +51,4 @@
 		return UML2Package.eINSTANCE.getDevice();
 	}
 
-
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.DEVICE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DEVICE__VISIBILITY:
-				return false;
-			case UML2Package.DEVICE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.DEVICE__NESTED_CLASSIFIER:
-				return false;
-			case UML2Package.DEVICE__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //DeviceImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DirectedRelationshipImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DirectedRelationshipImpl.java
index ec8f0ed..cd5c7db 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DirectedRelationshipImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DirectedRelationshipImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DirectedRelationshipImpl.java,v 1.11 2005/11/04 22:23:01 khussey Exp $
+ * $Id: DirectedRelationshipImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -96,6 +96,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -117,6 +118,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -140,6 +142,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationConstraintImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationConstraintImpl.java
index eaed236..c8f91bc 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationConstraintImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationConstraintImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DurationConstraintImpl.java,v 1.11 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DurationConstraintImpl.java,v 1.12 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -171,7 +171,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DURATION_CONSTRAINT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -190,7 +190,7 @@
 			case UML2Package.DURATION_CONSTRAINT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.DURATION_CONSTRAINT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.DURATION_CONSTRAINT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.DURATION_CONSTRAINT__NAME_EXPRESSION:
@@ -206,7 +206,7 @@
 			case UML2Package.DURATION_CONSTRAINT__NAMESPACE:
 				return isSetNamespace();
 			case UML2Package.DURATION_CONSTRAINT__SPECIFICATION:
-				return getSpecification() != null;
+				return isSetSpecification();
 			case UML2Package.DURATION_CONSTRAINT__CONSTRAINED_ELEMENT:
 				return constrainedElement != null && !constrainedElement.isEmpty();
 		}
@@ -214,12 +214,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DURATION_CONSTRAINT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //DurationConstraintImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationIntervalImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationIntervalImpl.java
index a6a5ed6..d0afa4d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationIntervalImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationIntervalImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DurationIntervalImpl.java,v 1.11 2005/11/04 22:23:00 khussey Exp $
+ * $Id: DurationIntervalImpl.java,v 1.12 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -75,14 +75,6 @@
 		return min;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetMins() {
-		return min != null && !min.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -104,11 +96,8 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getMaxes() {
-		if (max == null) {
-			max = new EObjectResolvingEList(Duration.class, this, UML2Package.DURATION_INTERVAL__MAX);
-		}
-		return max;
+	public boolean isSetMins() {
+		return min != null && !min.isEmpty();
 	}
 
 	/**
@@ -116,10 +105,14 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetMaxes() {
-		return max != null && !max.isEmpty();
+	public EList getMaxes() {
+		if (max == null) {
+			max = new EObjectResolvingEList(Duration.class, this, UML2Package.DURATION_INTERVAL__MAX);
+		}
+		return max;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -140,6 +133,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetMaxes() {
+		return max != null && !max.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DURATION_INTERVAL__EANNOTATIONS:
@@ -217,9 +219,9 @@
 			case UML2Package.DURATION_INTERVAL__OWNING_PARAMETER:
 				return getOwningParameter() != null;
 			case UML2Package.DURATION_INTERVAL__MIN:
-				return !getMins().isEmpty();
+				return isSetMins();
 			case UML2Package.DURATION_INTERVAL__MAX:
-				return !getMaxes().isEmpty();
+				return isSetMaxes();
 		}
 		return eDynamicIsSet(eFeature);
 	}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationObservationActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationObservationActionImpl.java
index 35e5d54..7092b15 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationObservationActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/DurationObservationActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: DurationObservationActionImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: DurationObservationActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,14 +102,6 @@
 		return duration;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetDurations() {
-		return duration != null && !duration.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -129,6 +121,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetDurations() {
+		return duration != null && !duration.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 * @deprecated Use #createDuration() instead.
 	 */
@@ -186,6 +187,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetValue() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
@@ -495,7 +505,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.DURATION_OBSERVATION_ACTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -558,7 +568,7 @@
 			case UML2Package.DURATION_OBSERVATION_ACTION__OBJECT:
 				return object != null;
 			case UML2Package.DURATION_OBSERVATION_ACTION__VALUE:
-				return getValue() != null;
+				return isSetValue();
 			case UML2Package.DURATION_OBSERVATION_ACTION__DURATION:
 				return isSetDurations();
 		}
@@ -566,14 +576,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.DURATION_OBSERVATION_ACTION__VALUE:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	public EList getInputs() {
 		if (input == null) {
 			input = new DerivedUnionEObjectEList(InputPin.class, this, UML2Package.DURATION_OBSERVATION_ACTION__INPUT, new EStructuralFeature[] {UML2Package.eINSTANCE.getStructuralFeatureAction_Object(), UML2Package.eINSTANCE.getDurationObservationAction_Duration()});
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImpl.java
index 5ba3dee..ec204fc 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ElementImpl.java,v 1.29 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ElementImpl.java,v 1.30 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -130,6 +130,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImportImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImportImpl.java
index 3e26863..53982a6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImportImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ElementImportImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ElementImportImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ElementImportImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -147,6 +147,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -169,6 +170,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -349,6 +351,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getElementImport_ImportingNamespace());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EncapsulatedClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EncapsulatedClassifierImpl.java
index f83972c..fab0d24 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EncapsulatedClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EncapsulatedClassifierImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: EncapsulatedClassifierImpl.java,v 1.21 2005/11/04 22:22:59 khussey Exp $
+ * $Id: EncapsulatedClassifierImpl.java,v 1.22 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -103,6 +103,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -524,7 +525,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ENCAPSULATED_CLASSIFIER__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -543,7 +544,7 @@
 			case UML2Package.ENCAPSULATED_CLASSIFIER__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ENCAPSULATED_CLASSIFIER__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ENCAPSULATED_CLASSIFIER__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ENCAPSULATED_CLASSIFIER__NAME_EXPRESSION:
@@ -611,14 +612,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ENCAPSULATED_CLASSIFIER__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -642,4 +635,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getEncapsulatedClassifier_OwnedPort());
 	}
 
+
 } //EncapsulatedClassifierImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationImpl.java
index ad79a8b..0b6f5c9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: EnumerationImpl.java,v 1.22 2005/11/04 22:23:00 khussey Exp $
+ * $Id: EnumerationImpl.java,v 1.23 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -551,7 +551,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ENUMERATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -570,7 +570,7 @@
 			case UML2Package.ENUMERATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ENUMERATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ENUMERATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ENUMERATION__NAME_EXPRESSION:
@@ -634,14 +634,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ENUMERATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -665,6 +657,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getEnumeration_OwnedLiteral());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationLiteralImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationLiteralImpl.java
index 95a0bc8..4fa2577 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationLiteralImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EnumerationLiteralImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: EnumerationLiteralImpl.java,v 1.11 2005/11/04 22:22:59 khussey Exp $
+ * $Id: EnumerationLiteralImpl.java,v 1.12 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -131,6 +131,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getEnumerationLiteral_Enumeration());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -415,7 +416,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.ENUMERATION_LITERAL__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -434,7 +435,7 @@
 			case UML2Package.ENUMERATION_LITERAL__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.ENUMERATION_LITERAL__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.ENUMERATION_LITERAL__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.ENUMERATION_LITERAL__NAME_EXPRESSION:
@@ -462,12 +463,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.ENUMERATION_LITERAL__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //EnumerationLiteralImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EventOccurrenceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EventOccurrenceImpl.java
index 48bad53..aba9b7a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EventOccurrenceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/EventOccurrenceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: EventOccurrenceImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: EventOccurrenceImpl.java,v 1.13 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -405,15 +405,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetCovereds() {
-		return covered != null && !covered.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public Lifeline getCovered(String name) {
 		for (Iterator i = getCovereds().iterator(); i.hasNext(); ) {
 			Lifeline covered = (Lifeline) i.next();
@@ -429,6 +420,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetCovereds() {
+		return covered != null && !covered.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -750,7 +750,7 @@
 			case UML2Package.EVENT_OCCURRENCE__NAME_EXPRESSION:
 				return nameExpression != null;
 			case UML2Package.EVENT_OCCURRENCE__COVERED:
-				return !getCovereds().isEmpty();
+				return isSetCovereds();
 			case UML2Package.EVENT_OCCURRENCE__GENERAL_ORDERING:
 				return generalOrdering != null && !generalOrdering.isEmpty();
 			case UML2Package.EVENT_OCCURRENCE__ENCLOSING_INTERACTION:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExceptionHandlerImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExceptionHandlerImpl.java
index 95ac209..ff43782 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExceptionHandlerImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExceptionHandlerImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExceptionHandlerImpl.java,v 1.8 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ExceptionHandlerImpl.java,v 1.9 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -274,6 +274,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getExceptionHandler_ProtectedNode());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutableNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutableNodeImpl.java
index f0a2245..616844b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutableNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutableNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExecutableNodeImpl.java,v 1.13 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ExecutableNodeImpl.java,v 1.14 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -101,6 +101,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutionEnvironmentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutionEnvironmentImpl.java
index f3a70cd..d234ca4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutionEnvironmentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExecutionEnvironmentImpl.java
@@ -8,15 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExecutionEnvironmentImpl.java,v 1.25 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ExecutionEnvironmentImpl.java,v 1.26 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
-import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.uml2.ExecutionEnvironment;
 import org.eclipse.uml2.UML2Package;
 
@@ -56,27 +52,4 @@
 	}
 
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.EXECUTION_ENVIRONMENT__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.EXECUTION_ENVIRONMENT__VISIBILITY:
-				return false;
-			case UML2Package.EXECUTION_ENVIRONMENT__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.EXECUTION_ENVIRONMENT__NESTED_CLASSIFIER:
-				return false;
-			case UML2Package.EXECUTION_ENVIRONMENT__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ExecutionEnvironmentImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpansionRegionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpansionRegionImpl.java
index 45b834a..6493415 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpansionRegionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpansionRegionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExpansionRegionImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ExpansionRegionImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -237,6 +237,10 @@
 					return ((InternalEList)getElementImports()).basicAdd(otherEnd, msgs);
 				case UML2Package.EXPANSION_REGION__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicAdd(otherEnd, msgs);
+				case UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.EXPANSION_REGION__VARIABLE:
 					return ((InternalEList)getVariables()).basicAdd(otherEnd, msgs);
 				case UML2Package.EXPANSION_REGION__CONTAINED_NODE:
@@ -300,6 +304,8 @@
 					return ((InternalEList)getElementImports()).basicRemove(otherEnd, msgs);
 				case UML2Package.EXPANSION_REGION__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicRemove(otherEnd, msgs);
+				case UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.EXPANSION_REGION__VARIABLE:
 					return ((InternalEList)getVariables()).basicRemove(otherEnd, msgs);
 				case UML2Package.EXPANSION_REGION__CONTAINED_NODE:
@@ -317,15 +323,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -656,7 +653,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.EXPANSION_REGION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -691,7 +688,7 @@
 			case UML2Package.EXPANSION_REGION__IN_GROUP:
 				return isSetInGroups();
 			case UML2Package.EXPANSION_REGION__ACTIVITY:
-				return getActivity() != null;
+				return isSetActivity();
 			case UML2Package.EXPANSION_REGION__REDEFINED_ELEMENT:
 				return isSetRedefinedElements();
 			case UML2Package.EXPANSION_REGION__IN_STRUCTURED_NODE:
@@ -746,16 +743,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.EXPANSION_REGION__ACTIVITY:
-				return false;
-			case UML2Package.EXPANSION_REGION__ACTIVITY_GROUP_ACTIVITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpressionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpressionImpl.java
index 65ff88f..c0bc261 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpressionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExpressionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExpressionImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ExpressionImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,6 +125,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtendImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtendImpl.java
index 1012dd5..07ef9f8 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtendImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtendImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExtendImpl.java,v 1.16 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ExtendImpl.java,v 1.17 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -164,6 +164,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -361,6 +362,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -382,6 +384,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -404,6 +407,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionEndImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionEndImpl.java
index bb4e391..524c918 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionEndImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionEndImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExtensionEndImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ExtensionEndImpl.java,v 1.13 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -255,7 +255,7 @@
 			case UML2Package.EXTENSION_END__IS_STATIC:
 				return ((eFlags & IS_STATIC_EFLAG) != 0) != IS_STATIC_EDEFAULT;
 			case UML2Package.EXTENSION_END__TYPE:
-				return basicGetType() != null;
+				return isSetType();
 			case UML2Package.EXTENSION_END__IS_ORDERED:
 				return ((eFlags & IS_ORDERED_EFLAG) != 0) != IS_ORDERED_EDEFAULT;
 			case UML2Package.EXTENSION_END__IS_UNIQUE:
@@ -269,7 +269,7 @@
 			case UML2Package.EXTENSION_END__LOWER_VALUE:
 				return lowerValue != null;
 			case UML2Package.EXTENSION_END__IS_READ_ONLY:
-				return isReadOnly() != IS_READ_ONLY_EDEFAULT;
+				return isSetIsReadOnly();
 			case UML2Package.EXTENSION_END__TEMPLATE_PARAMETER:
 				return templateParameter != null;
 			case UML2Package.EXTENSION_END__OWNING_PARAMETER:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionImpl.java
index 5b682c6..3f1e512 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ExtensionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ExtensionImpl.java,v 1.24 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ExtensionImpl.java,v 1.25 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -137,15 +137,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetOwnedEnds() {
-		return ownedEnd != null && !ownedEnd.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 * @deprecated Use #createOwnedEnd() instead.
 	 */
@@ -192,6 +183,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetOwnedEnds() {
+		return ownedEnd != null && !ownedEnd.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.EXTENSION__EANNOTATIONS:
@@ -290,7 +290,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.EXTENSION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -309,7 +309,7 @@
 			case UML2Package.EXTENSION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.EXTENSION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.EXTENSION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.EXTENSION__NAME_EXPRESSION:
@@ -367,7 +367,7 @@
 			case UML2Package.EXTENSION__IS_DERIVED:
 				return ((eFlags & IS_DERIVED_EFLAG) != 0) != IS_DERIVED_EDEFAULT;
 			case UML2Package.EXTENSION__OWNED_END:
-				return !getOwnedEnds().isEmpty();
+				return isSetOwnedEnds();
 			case UML2Package.EXTENSION__END_TYPE:
 				return !getEndTypes().isEmpty();
 			case UML2Package.EXTENSION__MEMBER_END:
@@ -381,12 +381,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.EXTENSION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ExtensionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/FeatureImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/FeatureImpl.java
index ecc6af1..7d7b9f3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/FeatureImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/FeatureImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: FeatureImpl.java,v 1.13 2005/11/04 22:23:01 khussey Exp $
+ * $Id: FeatureImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -138,6 +138,7 @@
 		return featuringClassifier;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationImpl.java
index aca41f2..a7d09ee 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: GeneralizationImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: GeneralizationImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -134,6 +134,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -156,6 +157,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -313,6 +315,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getGeneralization_Specific());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationSetImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationSetImpl.java
index 57683d2..ae453b6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationSetImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/GeneralizationSetImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: GeneralizationSetImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: GeneralizationSetImpl.java,v 1.13 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -504,7 +504,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.GENERALIZATION_SET__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -523,7 +523,7 @@
 			case UML2Package.GENERALIZATION_SET__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.GENERALIZATION_SET__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.GENERALIZATION_SET__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.GENERALIZATION_SET__NAME_EXPRESSION:
@@ -546,14 +546,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.GENERALIZATION_SET__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ImplementationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ImplementationImpl.java
index 3d21529..ee66a6e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ImplementationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ImplementationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ImplementationImpl.java,v 1.17 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ImplementationImpl.java,v 1.18 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -31,6 +31,7 @@
 import org.eclipse.uml2.BehavioredClassifier;
 import org.eclipse.uml2.Classifier;
 import org.eclipse.uml2.Component;
+//import org.eclipse.uml2.Element;
 import org.eclipse.uml2.Implementation;
 import org.eclipse.uml2.Interface;
 import org.eclipse.uml2.NamedElement;
@@ -41,6 +42,7 @@
 import org.eclipse.uml2.UML2Package;
 import org.eclipse.uml2.VisibilityKind;
 
+//import org.eclipse.uml2.common.util.DerivedUnionEObjectEList;
 import org.eclipse.uml2.common.util.SupersetEObjectResolvingEList;
 import org.eclipse.uml2.common.util.SupersetEObjectWithInverseResolvingEList;
 
@@ -552,7 +554,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.IMPLEMENTATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -571,7 +573,7 @@
 			case UML2Package.IMPLEMENTATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.IMPLEMENTATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.IMPLEMENTATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.IMPLEMENTATION__NAME_EXPRESSION:
@@ -607,12 +609,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.IMPLEMENTATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ImplementationImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IncludeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IncludeImpl.java
index 9f6ec72..7f7ca9b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IncludeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IncludeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: IncludeImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: IncludeImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -135,6 +135,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -230,6 +231,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -251,6 +253,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationFlowImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationFlowImpl.java
index 916fe24..0cf1ff0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationFlowImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationFlowImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InformationFlowImpl.java,v 1.15 2005/11/04 22:22:59 khussey Exp $
+ * $Id: InformationFlowImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -141,6 +141,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -163,6 +164,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -184,6 +186,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -396,7 +399,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INFORMATION_FLOW__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -415,7 +418,7 @@
 			case UML2Package.INFORMATION_FLOW__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INFORMATION_FLOW__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INFORMATION_FLOW__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INFORMATION_FLOW__NAME_EXPRESSION:
@@ -440,14 +443,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INFORMATION_FLOW__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationItemImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationItemImpl.java
index 8594be9..b60ac0c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationItemImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InformationItemImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InformationItemImpl.java,v 1.20 2005/11/04 22:23:01 khussey Exp $
+ * $Id: InformationItemImpl.java,v 1.21 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -383,7 +383,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INFORMATION_ITEM__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -402,7 +402,7 @@
 			case UML2Package.INFORMATION_ITEM__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INFORMATION_ITEM__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INFORMATION_ITEM__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INFORMATION_ITEM__NAME_EXPRESSION:
@@ -462,12 +462,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INFORMATION_ITEM__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //InformationItemImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InstanceSpecificationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InstanceSpecificationImpl.java
index 8d69eb6..75bc0f7 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InstanceSpecificationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InstanceSpecificationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InstanceSpecificationImpl.java,v 1.21 2005/11/04 22:23:01 khussey Exp $
+ * $Id: InstanceSpecificationImpl.java,v 1.22 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -155,6 +155,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -684,7 +685,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INSTANCE_SPECIFICATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -703,7 +704,7 @@
 			case UML2Package.INSTANCE_SPECIFICATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INSTANCE_SPECIFICATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INSTANCE_SPECIFICATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INSTANCE_SPECIFICATION__NAME_EXPRESSION:
@@ -728,14 +729,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INSTANCE_SPECIFICATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionConstraintImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionConstraintImpl.java
index 6dc0d8f..55eaf50 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionConstraintImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionConstraintImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InteractionConstraintImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: InteractionConstraintImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -112,6 +112,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -464,7 +465,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INTERACTION_CONSTRAINT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -483,7 +484,7 @@
 			case UML2Package.INTERACTION_CONSTRAINT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INTERACTION_CONSTRAINT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INTERACTION_CONSTRAINT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INTERACTION_CONSTRAINT__NAME_EXPRESSION:
@@ -511,12 +512,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INTERACTION_CONSTRAINT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-	
 } //InteractionConstraintImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionFragmentImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionFragmentImpl.java
index 582af3f..4b0130a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionFragmentImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionFragmentImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InteractionFragmentImpl.java,v 1.12 2005/11/04 22:23:00 khussey Exp $
+ * $Id: InteractionFragmentImpl.java,v 1.13 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -121,6 +121,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -305,6 +306,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteractionFragment_EnclosingOperand());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionImpl.java
index 01712ea..20fc015 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InteractionImpl.java,v 1.26 2005/11/04 22:23:01 khussey Exp $
+ * $Id: InteractionImpl.java,v 1.27 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -544,6 +544,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteractionFragment_EnclosingOperand());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -575,6 +576,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteraction_FormalGate());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -619,6 +621,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.INTERACTION__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.INTERACTION__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.INTERACTION__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.INTERACTION__CONTEXT:
@@ -654,15 +658,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.INTERACTION__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1305,7 +1300,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INTERACTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1324,7 +1319,7 @@
 			case UML2Package.INTERACTION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INTERACTION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INTERACTION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INTERACTION__NAME_EXPRESSION:
@@ -1354,11 +1349,11 @@
 			case UML2Package.INTERACTION__FEATURE:
 				return isSetFeatures();
 			case UML2Package.INTERACTION__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.INTERACTION__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.INTERACTION__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.INTERACTION__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.INTERACTION__ATTRIBUTE:
@@ -1378,7 +1373,7 @@
 			case UML2Package.INTERACTION__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.INTERACTION__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.INTERACTION__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.INTERACTION__IMPLEMENTATION:
@@ -1388,7 +1383,7 @@
 			case UML2Package.INTERACTION__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.INTERACTION__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.INTERACTION__PART:
 				return !getParts().isEmpty();
 			case UML2Package.INTERACTION__ROLE:
@@ -1449,18 +1444,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INTERACTION__VISIBILITY:
-				return false;
-			case UML2Package.INTERACTION__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.INTERACTION__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1521,4 +1504,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteractionFragment_GeneralOrdering());
 	}
 
+
 } //InteractionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOccurrenceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOccurrenceImpl.java
index b4bd355..92213ed 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOccurrenceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOccurrenceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InteractionOccurrenceImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: InteractionOccurrenceImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -126,6 +126,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOperandImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOperandImpl.java
index 26df726..1e269cd 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOperandImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InteractionOperandImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InteractionOperandImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: InteractionOperandImpl.java,v 1.15 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -420,6 +420,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteractionFragment_EnclosingOperand());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -839,4 +840,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInteractionOperand_Guard());
 	}
 
+
 } //InteractionOperandImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterfaceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterfaceImpl.java
index a01da95..2ae2f93 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterfaceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterfaceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InterfaceImpl.java,v 1.26 2005/11/04 22:22:59 khussey Exp $
+ * $Id: InterfaceImpl.java,v 1.27 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -173,6 +173,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -195,6 +196,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -901,7 +903,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INTERFACE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -920,7 +922,7 @@
 			case UML2Package.INTERFACE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INTERFACE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INTERFACE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INTERFACE__NAME_EXPRESSION:
@@ -990,14 +992,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INTERFACE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1038,6 +1032,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInterface_Protocol());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1063,6 +1058,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getInterface_RedefinedInterface());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterruptibleActivityRegionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterruptibleActivityRegionImpl.java
index 634f5ae..ed87e9e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterruptibleActivityRegionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InterruptibleActivityRegionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InterruptibleActivityRegionImpl.java,v 1.9 2005/11/04 22:23:02 khussey Exp $
+ * $Id: InterruptibleActivityRegionImpl.java,v 1.10 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -129,14 +129,6 @@
 		return containedNode;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetContainedNodes() {
-		return containedNode != null && !containedNode.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -158,11 +150,24 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetContainedNodes() {
+		return containedNode != null && !containedNode.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__EANNOTATIONS:
 					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
+				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__INTERRUPTING_EDGE:
 					return ((InternalEList)getInterruptingEdges()).basicAdd(otherEnd, msgs);
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__CONTAINED_NODE:
@@ -176,17 +181,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY:
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -199,6 +193,8 @@
 					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__OWNED_COMMENT:
 					return ((InternalEList)getOwnedComments()).basicRemove(otherEnd, msgs);
+				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__INTERRUPTING_EDGE:
 					return ((InternalEList)getInterruptingEdges()).basicRemove(otherEnd, msgs);
 				case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__CONTAINED_NODE:
@@ -210,15 +206,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.INTERRUPTIBLE_ACTIVITY_REGION__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IntervalConstraintImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IntervalConstraintImpl.java
index a0d4050..c5f005d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IntervalConstraintImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/IntervalConstraintImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: IntervalConstraintImpl.java,v 1.11 2005/11/04 22:23:01 khussey Exp $
+ * $Id: IntervalConstraintImpl.java,v 1.12 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -170,7 +170,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.INTERVAL_CONSTRAINT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -189,7 +189,7 @@
 			case UML2Package.INTERVAL_CONSTRAINT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.INTERVAL_CONSTRAINT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.INTERVAL_CONSTRAINT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.INTERVAL_CONSTRAINT__NAME_EXPRESSION:
@@ -205,7 +205,7 @@
 			case UML2Package.INTERVAL_CONSTRAINT__NAMESPACE:
 				return isSetNamespace();
 			case UML2Package.INTERVAL_CONSTRAINT__SPECIFICATION:
-				return getSpecification() != null;
+				return isSetSpecification();
 			case UML2Package.INTERVAL_CONSTRAINT__CONSTRAINED_ELEMENT:
 				return constrainedElement != null && !constrainedElement.isEmpty();
 		}
@@ -213,12 +213,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.INTERVAL_CONSTRAINT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //IntervalConstraintImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InvocationActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InvocationActionImpl.java
index 19f8717..c2a9929 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InvocationActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/InvocationActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: InvocationActionImpl.java,v 1.14 2005/11/04 22:23:02 khussey Exp $
+ * $Id: InvocationActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -115,6 +115,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/JoinNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/JoinNodeImpl.java
index e5896da..a22aaf4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/JoinNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/JoinNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: JoinNodeImpl.java,v 1.14 2005/11/04 22:23:00 khussey Exp $
+ * $Id: JoinNodeImpl.java,v 1.15 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -123,6 +123,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LifelineImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LifelineImpl.java
index a5d7890..ebfdb57 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LifelineImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LifelineImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: LifelineImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: LifelineImpl.java,v 1.15 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -142,6 +142,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -390,6 +391,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getLifeline_Interaction());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LinkEndCreationDataImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LinkEndCreationDataImpl.java
index f4b7ff3..e0b4544 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LinkEndCreationDataImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LinkEndCreationDataImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: LinkEndCreationDataImpl.java,v 1.12 2005/11/04 22:23:00 khussey Exp $
+ * $Id: LinkEndCreationDataImpl.java,v 1.13 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -308,7 +308,7 @@
 			case UML2Package.LINK_END_CREATION_DATA__END:
 				return end != null;
 			case UML2Package.LINK_END_CREATION_DATA__QUALIFIER:
-				return !getQualifiers().isEmpty();
+				return isSetQualifiers();
 			case UML2Package.LINK_END_CREATION_DATA__IS_REPLACE_ALL:
 				return ((eFlags & IS_REPLACE_ALL_EFLAG) != 0) != IS_REPLACE_ALL_EDEFAULT;
 			case UML2Package.LINK_END_CREATION_DATA__INSERT_AT:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LoopNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LoopNodeImpl.java
index 1a27e58..8e9023b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LoopNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/LoopNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: LoopNodeImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: LoopNodeImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -205,6 +205,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -227,6 +228,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -626,6 +628,8 @@
 					return ((InternalEList)getElementImports()).basicRemove(otherEnd, msgs);
 				case UML2Package.LOOP_NODE__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicRemove(otherEnd, msgs);
+				case UML2Package.LOOP_NODE__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.LOOP_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.LOOP_NODE__VARIABLE:
 					return ((InternalEList)getVariables()).basicRemove(otherEnd, msgs);
 				case UML2Package.LOOP_NODE__CONTAINED_NODE:
@@ -645,15 +649,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.LOOP_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.LOOP_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1038,7 +1033,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.LOOP_NODE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1073,7 +1068,7 @@
 			case UML2Package.LOOP_NODE__IN_GROUP:
 				return isSetInGroups();
 			case UML2Package.LOOP_NODE__ACTIVITY:
-				return getActivity() != null;
+				return isSetActivity();
 			case UML2Package.LOOP_NODE__REDEFINED_ELEMENT:
 				return isSetRedefinedElements();
 			case UML2Package.LOOP_NODE__IN_STRUCTURED_NODE:
@@ -1140,16 +1135,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.LOOP_NODE__ACTIVITY:
-				return false;
-			case UML2Package.LOOP_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1189,4 +1174,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getLoopNode_LoopVariable());
 	}
 
+
 } //LoopNodeImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ManifestationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ManifestationImpl.java
index e69a1e7..e220cfb 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ManifestationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ManifestationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ManifestationImpl.java,v 1.16 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ManifestationImpl.java,v 1.17 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -344,7 +344,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.MANIFESTATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -363,7 +363,7 @@
 			case UML2Package.MANIFESTATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.MANIFESTATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.MANIFESTATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.MANIFESTATION__NAME_EXPRESSION:
@@ -393,12 +393,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.MANIFESTATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ManifestationImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MessageImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MessageImpl.java
index 136d325..f877305 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MessageImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MessageImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: MessageImpl.java,v 1.12 2005/11/04 22:23:00 khussey Exp $
+ * $Id: MessageImpl.java,v 1.13 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -186,6 +186,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -535,6 +536,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getMessage_Interaction());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ModelImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ModelImpl.java
index 6560ced..e67ed9b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ModelImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ModelImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ModelImpl.java,v 1.17 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ModelImpl.java,v 1.18 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -328,7 +328,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.MODEL__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -347,7 +347,7 @@
 			case UML2Package.MODEL__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.MODEL__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.MODEL__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.MODEL__NAME_EXPRESSION:
@@ -388,14 +388,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.MODEL__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MultiplicityElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MultiplicityElementImpl.java
index a3f5c53..cf2e088 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MultiplicityElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/MultiplicityElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: MultiplicityElementImpl.java,v 1.16 2005/11/04 22:22:59 khussey Exp $
+ * $Id: MultiplicityElementImpl.java,v 1.17 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -176,6 +176,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamedElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamedElementImpl.java
index 165095e..a9439b4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamedElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamedElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: NamedElementImpl.java,v 1.21 2005/11/04 22:23:01 khussey Exp $
+ * $Id: NamedElementImpl.java,v 1.22 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -174,6 +174,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -453,9 +454,8 @@
 	 * @generated
 	 */
 	public Element basicGetOwner() {
-		Namespace namespace = basicGetNamespace();			
-		if (namespace != null) {
-			return namespace;
+		if (isSetNamespace()) {
+			return basicGetNamespace();
 		}
 		return super.basicGetOwner();
 	}
@@ -470,6 +470,7 @@
 			|| isSetNamespace();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamespaceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamespaceImpl.java
index 7790c1b..e43b35e 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamespaceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NamespaceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: NamespaceImpl.java,v 1.23 2005/11/04 22:23:00 khussey Exp $
+ * $Id: NamespaceImpl.java,v 1.24 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -154,6 +154,7 @@
 			|| isSetOwnedMembers();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -469,6 +470,7 @@
 		return eIsSet(UML2Package.eINSTANCE.getNamespace_OwnedRule());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -497,9 +499,8 @@
 		if (eIsSet(UML2Package.eINSTANCE.getNamespace_PackageImport())) {
 			ownedElement.addAll(getPackageImports());
 		}
-		EList ownedMember = getOwnedMembers();
-		if (!ownedMember.isEmpty()) {
-			for (Iterator i = ((InternalEList) ownedMember).basicIterator(); i.hasNext(); ) {
+		if (isSetOwnedMembers()) {
+			for (Iterator i = ((InternalEList) getOwnedMembers()).basicIterator(); i.hasNext(); ) {
 				ownedElement.add(i.next());
 			}
 		}
@@ -537,6 +538,7 @@
 			|| isSetOwnedMembers();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -798,9 +800,8 @@
 				member.add(i.next());
 			}
 		}
-		EList ownedMember = getOwnedMembers();
-		if (!ownedMember.isEmpty()) {
-			for (Iterator i = ((InternalEList) ownedMember).basicIterator(); i.hasNext(); ) {
+		if (isSetOwnedMembers()) {
+			for (Iterator i = ((InternalEList) getOwnedMembers()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
 		}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NodeImpl.java
index cf5a78b..e5a75f9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/NodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: NodeImpl.java,v 1.28 2005/11/04 22:23:00 khussey Exp $
+ * $Id: NodeImpl.java,v 1.29 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -227,14 +227,6 @@
 		return nestedNode;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetNestedNodes() {
-		return nestedNode != null && !nestedNode.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -256,6 +248,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetNestedNodes() {
+		return nestedNode != null && !nestedNode.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Node createNestedNode(EClass eClass) {
 		Node newNestedNode = (Node) eClass.getEPackage().getEFactoryInstance().create(eClass);
 		if (eNotificationRequired()) {
@@ -305,6 +306,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetNestedClassifiers() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
@@ -346,6 +356,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.NODE__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.NODE__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.NODE__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.NODE__DEPLOYMENT:
@@ -359,15 +371,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.NODE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -843,7 +846,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.NODE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -862,7 +865,7 @@
 			case UML2Package.NODE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.NODE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.NODE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.NODE__NAME_EXPRESSION:
@@ -892,11 +895,11 @@
 			case UML2Package.NODE__FEATURE:
 				return isSetFeatures();
 			case UML2Package.NODE__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.NODE__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.NODE__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.NODE__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.NODE__ATTRIBUTE:
@@ -916,7 +919,7 @@
 			case UML2Package.NODE__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.NODE__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.NODE__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.NODE__IMPLEMENTATION:
@@ -926,7 +929,7 @@
 			case UML2Package.NODE__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.NODE__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.NODE__PART:
 				return !getParts().isEmpty();
 			case UML2Package.NODE__ROLE:
@@ -942,7 +945,7 @@
 			case UML2Package.NODE__EXTENSION:
 				return !getExtensions().isEmpty();
 			case UML2Package.NODE__NESTED_CLASSIFIER:
-				return !getNestedClassifiers().isEmpty();
+				return isSetNestedClassifiers();
 			case UML2Package.NODE__IS_ACTIVE:
 				return ((eFlags & IS_ACTIVE_EFLAG) != 0) != IS_ACTIVE_EDEFAULT;
 			case UML2Package.NODE__OWNED_RECEPTION:
@@ -957,20 +960,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.NODE__VISIBILITY:
-				return false;
-			case UML2Package.NODE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.NODE__NESTED_CLASSIFIER:
-				return false;
-			case UML2Package.NODE__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1027,6 +1016,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getDeploymentTarget_Deployment());
 	}
 
+
 	protected EList getOwnedMembersHelper(EList ownedMember) {
 		super.getOwnedMembersHelper(ownedMember);
 		if (eIsSet(UML2Package.eINSTANCE.getNode_NestedNode())) {
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ObjectNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ObjectNodeImpl.java
index 799125e..ede88fb 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ObjectNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ObjectNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ObjectNodeImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ObjectNodeImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -202,6 +202,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/OperationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/OperationImpl.java
index d7e8b16..edf84cf 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/OperationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/OperationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: OperationImpl.java,v 1.29 2005/11/04 22:23:00 khussey Exp $
+ * $Id: OperationImpl.java,v 1.30 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -487,6 +487,7 @@
 		return redefinitionContext;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -510,6 +511,7 @@
 		return featuringClassifier;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -560,6 +562,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetOwnedParameters() {
+		return formalParameter != null && !formalParameter.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
     public Parameter getOwnedParameter(String name) {
@@ -896,6 +907,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1057,15 +1069,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetRaisedExceptions() {
-		return raisedException != null && !raisedException.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public Type getRaisedException(String name) {
 		for (Iterator i = getRaisedExceptions().iterator(); i.hasNext(); ) {
 			Type raisedException = (Type) i.next();
@@ -1079,19 +1082,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
-	public EList getFormalParameters() {
-		return getOwnedParameters();
+	public boolean isSetRaisedExceptions() {
+		return raisedException != null && !raisedException.isEmpty();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
+	 * @generated NOT
 	 */
-	public boolean isSetFormalParameters() {
-		return formalParameter != null && !formalParameter.isEmpty();
+	public EList getFormalParameters() {
+		return getOwnedParameters();
 	}
 
 	/**
@@ -1123,6 +1126,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
+	public boolean isSetFormalParameters() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
 	public Type basicGetType() {
 		return type();
 	}
@@ -1130,10 +1142,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
+	 * @generated NOT
 	 */
 	public boolean isSetType() {
-		return basicGetType() != null;
+		return null != returnResult
+			&& 1 == returnResult.size()
+			&& ((Parameter) returnResult.get(0))
+				.eIsSet(UML2Package.eINSTANCE.getTypedElement_Type());
 	}
 
 	/**
@@ -1181,6 +1196,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getOperation_Datatype());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1216,6 +1232,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getOperation_BodyCondition());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1241,6 +1258,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getOperation_RedefinedOperation());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1729,7 +1747,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.OPERATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1774,11 +1792,11 @@
 			case UML2Package.OPERATION__PARAMETER:
 				return isSetParameters();
 			case UML2Package.OPERATION__FORMAL_PARAMETER:
-				return !getFormalParameters().isEmpty();
+				return isSetFormalParameters();
 			case UML2Package.OPERATION__RETURN_RESULT:
 				return returnResult != null && !returnResult.isEmpty();
 			case UML2Package.OPERATION__RAISED_EXCEPTION:
-				return !getRaisedExceptions().isEmpty();
+				return isSetRaisedExceptions();
 			case UML2Package.OPERATION__IS_ABSTRACT:
 				return ((eFlags & IS_ABSTRACT_EFLAG) != 0) != IS_ABSTRACT_EDEFAULT;
 			case UML2Package.OPERATION__METHOD:
@@ -1786,15 +1804,15 @@
 			case UML2Package.OPERATION__CONCURRENCY:
 				return concurrency != CONCURRENCY_EDEFAULT;
 			case UML2Package.OPERATION__TYPE:
-				return basicGetType() != null;
+				return isSetType();
 			case UML2Package.OPERATION__IS_ORDERED:
-				return isOrdered() != IS_ORDERED_EDEFAULT;
+				return isSetIsOrdered();
 			case UML2Package.OPERATION__IS_UNIQUE:
-				return isUnique() != IS_UNIQUE_EDEFAULT;
+				return isSetIsUnique();
 			case UML2Package.OPERATION__LOWER:
-				return getLower() != LOWER_EDEFAULT;
+				return isSetLower();
 			case UML2Package.OPERATION__UPPER:
-				return getUpper() != UPPER_EDEFAULT;
+				return isSetUpper();
 			case UML2Package.OPERATION__UPPER_VALUE:
 				return upperValue != null;
 			case UML2Package.OPERATION__LOWER_VALUE:
@@ -1804,7 +1822,7 @@
 			case UML2Package.OPERATION__OWNING_PARAMETER:
 				return getOwningParameter() != null;
 			case UML2Package.OPERATION__OWNED_PARAMETER:
-				return !getOwnedParameters().isEmpty();
+				return isSetOwnedParameters();
 			case UML2Package.OPERATION__CLASS_:
 				return getClass_() != null;
 			case UML2Package.OPERATION__IS_QUERY:
@@ -1823,21 +1841,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.OPERATION__FORMAL_PARAMETER:
-				return false;
-			case UML2Package.OPERATION__OWNED_PARAMETER:
-				return formalParameter != null && !formalParameter.isEmpty();
-			case UML2Package.OPERATION__TYPE:
-				return null != returnResult
-					&& 1 == returnResult.size()
-					&& ((Parameter) returnResult.get(0))
-						.eIsSet(UML2Package.eINSTANCE.getTypedElement_Type());
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1949,6 +1952,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getMultiplicityElement_LowerValue());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImpl.java
index 98d93eb..5a47df2 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PackageImpl.java,v 1.34 2005/11/04 22:22:59 khussey Exp $
+ * $Id: PackageImpl.java,v 1.35 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -386,14 +386,6 @@
 		return ownedMember;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetOwnedMembers() {
-		return ownedMember != null && !ownedMember.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -413,6 +405,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetOwnedMembers() {
+		return ownedMember != null && !ownedMember.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
 	public PackageableElement createOwnedMember(EClass eClass) {
@@ -553,6 +554,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -575,6 +577,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetVisibility() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public boolean mustBeOwned() {
@@ -630,6 +641,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getPackage_NestingPackage());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -991,7 +1003,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.PACKAGE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1010,7 +1022,7 @@
 			case UML2Package.PACKAGE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.PACKAGE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.PACKAGE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.PACKAGE__NAME_EXPRESSION:
@@ -1049,14 +1061,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PACKAGE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImportImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImportImpl.java
index df00f56..3dbbff7 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImportImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageImportImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PackageImportImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: PackageImportImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,6 +125,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -147,6 +148,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -285,6 +287,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getPackageImport_ImportingNamespace());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageMergeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageMergeImpl.java
index f03239e..6a67e78 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageMergeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageMergeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PackageMergeImpl.java,v 1.11 2005/11/04 22:22:59 khussey Exp $
+ * $Id: PackageMergeImpl.java,v 1.12 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -98,6 +98,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -120,6 +121,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -226,6 +228,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getPackageMerge_MergingPackage());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageableElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageableElementImpl.java
index 75038ee..da46fdd 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageableElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PackageableElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PackageableElementImpl.java,v 1.13 2005/11/04 22:23:01 khussey Exp $
+ * $Id: PackageableElementImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -250,6 +250,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -272,6 +273,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetVisibility() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
@@ -490,7 +500,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.PACKAGEABLE_ELEMENT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -509,7 +519,7 @@
 			case UML2Package.PACKAGEABLE_ELEMENT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.PACKAGEABLE_ELEMENT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.PACKAGEABLE_ELEMENT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.PACKAGEABLE_ELEMENT__NAME_EXPRESSION:
@@ -524,14 +534,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PACKAGEABLE_ELEMENT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterImpl.java
index a826359..01924a5 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ParameterImpl.java,v 1.18 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ParameterImpl.java,v 1.19 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -361,6 +361,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -910,6 +911,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameter_Operation());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterSetImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterSetImpl.java
index 46e8075..759b082 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterSetImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterSetImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ParameterSetImpl.java,v 1.12 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ParameterSetImpl.java,v 1.13 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -114,6 +114,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableClassifierImpl.java
index 7bd2146..f46aef6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableClassifierImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ParameterableClassifierImpl.java,v 1.20 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ParameterableClassifierImpl.java,v 1.21 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.ParameterableClassifier;
 import org.eclipse.uml2.UML2Package;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PARAMETERABLE_CLASSIFIER__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //ParameterableClassifierImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableElementImpl.java
index 25228a2..0081e92 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ParameterableElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ParameterableElementImpl.java,v 1.11 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ParameterableElementImpl.java,v 1.12 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -204,6 +204,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PermissionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PermissionImpl.java
index b084054..f7a1782 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PermissionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PermissionImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PermissionImpl.java,v 1.10 2005/11/04 22:23:00 khussey Exp $
+ * $Id: PermissionImpl.java,v 1.11 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.Permission;
 import org.eclipse.uml2.UML2Package;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PERMISSION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //PermissionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PinImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PinImpl.java
index 684efbe..78ac433 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PinImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PinImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PinImpl.java,v 1.13 2005/11/04 22:23:01 khussey Exp $
+ * $Id: PinImpl.java,v 1.14 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -185,6 +185,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PortImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PortImpl.java
index ceea718..78a2761 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PortImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PortImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PortImpl.java,v 1.16 2005/11/04 22:23:00 khussey Exp $
+ * $Id: PortImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -762,7 +762,7 @@
 			case UML2Package.PORT__LOWER_VALUE:
 				return lowerValue != null;
 			case UML2Package.PORT__IS_READ_ONLY:
-				return isReadOnly() != IS_READ_ONLY_EDEFAULT;
+				return isSetIsReadOnly();
 			case UML2Package.PORT__TEMPLATE_PARAMETER:
 				return templateParameter != null;
 			case UML2Package.PORT__OWNING_PARAMETER:
@@ -862,4 +862,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getPort_RedefinedPort());
 	}
 
+
 } //PortImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveFunctionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveFunctionImpl.java
index 18e6c53..aa706a9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveFunctionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveFunctionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PrimitiveFunctionImpl.java,v 1.11 2005/11/04 22:23:01 khussey Exp $
+ * $Id: PrimitiveFunctionImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -308,7 +308,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.PRIMITIVE_FUNCTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -327,7 +327,7 @@
 			case UML2Package.PRIMITIVE_FUNCTION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.PRIMITIVE_FUNCTION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.PRIMITIVE_FUNCTION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.PRIMITIVE_FUNCTION__NAME_EXPRESSION:
@@ -346,14 +346,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PRIMITIVE_FUNCTION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveTypeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveTypeImpl.java
index 5d7452b..30edf70 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveTypeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PrimitiveTypeImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PrimitiveTypeImpl.java,v 1.20 2005/11/04 22:23:02 khussey Exp $
+ * $Id: PrimitiveTypeImpl.java,v 1.21 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.PrimitiveType;
 import org.eclipse.uml2.UML2Package;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PRIMITIVE_TYPE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-	
 } //PrimitiveTypeImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProfileImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProfileImpl.java
index 956c22e..046f84b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProfileImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProfileImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ProfileImpl.java,v 1.24 2005/11/04 22:22:59 khussey Exp $
+ * $Id: ProfileImpl.java,v 1.25 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -126,6 +126,7 @@
 		return ownedMember;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -533,7 +534,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.PROFILE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -552,7 +553,7 @@
 			case UML2Package.PROFILE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.PROFILE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.PROFILE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.PROFILE__NAME_EXPRESSION:
@@ -598,14 +599,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PROFILE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PropertyImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PropertyImpl.java
index 8a0dec0..9622aac 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PropertyImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/PropertyImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: PropertyImpl.java,v 1.26 2005/11/04 22:22:59 khussey Exp $
+ * $Id: PropertyImpl.java,v 1.27 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -419,6 +419,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -548,6 +549,7 @@
 		return featuringClassifier;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1187,6 +1189,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getProperty_Datatype());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1212,6 +1215,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getProperty_RedefinedProperty());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1240,6 +1244,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getProperty_AssociationEnd());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1754,7 +1759,7 @@
 			case UML2Package.PROPERTY__LOWER_VALUE:
 				return lowerValue != null;
 			case UML2Package.PROPERTY__IS_READ_ONLY:
-				return isReadOnly() != IS_READ_ONLY_EDEFAULT;
+				return isSetIsReadOnly();
 			case UML2Package.PROPERTY__TEMPLATE_PARAMETER:
 				return templateParameter != null;
 			case UML2Package.PROPERTY__OWNING_PARAMETER:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolConformanceImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolConformanceImpl.java
index e7e5eba..270e82b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolConformanceImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolConformanceImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ProtocolConformanceImpl.java,v 1.11 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ProtocolConformanceImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -99,6 +99,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -121,6 +122,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -227,6 +229,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getProtocolConformance_SpecificMachine());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolStateMachineImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolStateMachineImpl.java
index 52f6e82..a16bb47 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolStateMachineImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolStateMachineImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ProtocolStateMachineImpl.java,v 1.26 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ProtocolStateMachineImpl.java,v 1.27 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -176,6 +176,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__CONTEXT:
@@ -188,6 +190,10 @@
 					return basicSetSpecification((BehavioralFeature)otherEnd, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__REGION:
 					return ((InternalEList)getRegions()).basicAdd(otherEnd, msgs);
+				case UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__CONFORMANCE:
 					return ((InternalEList)getConformances()).basicAdd(otherEnd, msgs);
 				default:
@@ -199,19 +205,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			case UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -286,6 +279,8 @@
 					return ((InternalEList)getRegions()).basicRemove(otherEnd, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__CONNECTION_POINT:
 					return ((InternalEList)getConnectionPoints()).basicRemove(otherEnd, msgs);
+				case UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
+					return eBasicSetContainer(null, UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
 				case UML2Package.PROTOCOL_STATE_MACHINE__CONFORMANCE:
 					return ((InternalEList)getConformances()).basicRemove(otherEnd, msgs);
 				default:
@@ -295,15 +290,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
-				return eBasicSetContainer(null, UML2Package.PROTOCOL_STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -804,7 +790,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.PROTOCOL_STATE_MACHINE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -823,7 +809,7 @@
 			case UML2Package.PROTOCOL_STATE_MACHINE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.PROTOCOL_STATE_MACHINE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.PROTOCOL_STATE_MACHINE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.PROTOCOL_STATE_MACHINE__NAME_EXPRESSION:
@@ -853,11 +839,11 @@
 			case UML2Package.PROTOCOL_STATE_MACHINE__FEATURE:
 				return isSetFeatures();
 			case UML2Package.PROTOCOL_STATE_MACHINE__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.PROTOCOL_STATE_MACHINE__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.PROTOCOL_STATE_MACHINE__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.PROTOCOL_STATE_MACHINE__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.PROTOCOL_STATE_MACHINE__ATTRIBUTE:
@@ -877,7 +863,7 @@
 			case UML2Package.PROTOCOL_STATE_MACHINE__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.PROTOCOL_STATE_MACHINE__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.PROTOCOL_STATE_MACHINE__IMPLEMENTATION:
@@ -887,7 +873,7 @@
 			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.PROTOCOL_STATE_MACHINE__PART:
 				return !getParts().isEmpty();
 			case UML2Package.PROTOCOL_STATE_MACHINE__ROLE:
@@ -943,18 +929,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.PROTOCOL_STATE_MACHINE__VISIBILITY:
-				return false;
-			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.PROTOCOL_STATE_MACHINE__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -978,4 +952,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getProtocolStateMachine_Conformance());
 	}
 
+
 } //ProtocolStateMachineImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolTransitionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolTransitionImpl.java
index 6cb427d..085834b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolTransitionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ProtocolTransitionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ProtocolTransitionImpl.java,v 1.16 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ProtocolTransitionImpl.java,v 1.17 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,6 +125,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RaiseExceptionActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RaiseExceptionActionImpl.java
index d4da109..01450c5 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RaiseExceptionActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RaiseExceptionActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RaiseExceptionActionImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: RaiseExceptionActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -97,6 +97,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadExtentActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadExtentActionImpl.java
index 0580cd9..701dbc9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadExtentActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadExtentActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadExtentActionImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ReadExtentActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -113,6 +113,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadIsClassifiedObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadIsClassifiedObjectActionImpl.java
index 9ff1231..c3e05f3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadIsClassifiedObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadIsClassifiedObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadIsClassifiedObjectActionImpl.java,v 1.15 2005/11/04 22:23:02 khussey Exp $
+ * $Id: ReadIsClassifiedObjectActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -147,6 +147,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -169,6 +170,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkActionImpl.java
index e229cf6..7d21843 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadLinkActionImpl.java,v 1.15 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ReadLinkActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -101,6 +101,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndActionImpl.java
index 22f7fa1..b55a3ee 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadLinkObjectEndActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ReadLinkObjectEndActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -126,6 +126,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -148,6 +149,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndQualifierActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndQualifierActionImpl.java
index 18cb93a..7c9d9fd 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndQualifierActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadLinkObjectEndQualifierActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadLinkObjectEndQualifierActionImpl.java,v 1.15 2005/11/04 22:22:59 khussey Exp $
+ * $Id: ReadLinkObjectEndQualifierActionImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -126,6 +126,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -148,6 +149,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadSelfActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadSelfActionImpl.java
index 5eb137a..3d35ae4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadSelfActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadSelfActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadSelfActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ReadSelfActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -101,6 +101,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadStructuralFeatureActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadStructuralFeatureActionImpl.java
index 4a0af9c..51ec13b 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadStructuralFeatureActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadStructuralFeatureActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadStructuralFeatureActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: ReadStructuralFeatureActionImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -103,6 +103,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadVariableActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadVariableActionImpl.java
index fb0732f..cfe44fe 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadVariableActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReadVariableActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReadVariableActionImpl.java,v 1.15 2005/11/04 22:23:04 khussey Exp $
+ * $Id: ReadVariableActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,6 +102,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RealizationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RealizationImpl.java
index 80e5b57..92bd721 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RealizationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RealizationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RealizationImpl.java,v 1.16 2005/11/04 22:23:02 khussey Exp $
+ * $Id: RealizationImpl.java,v 1.17 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -240,6 +240,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getRealization_Abstraction());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -550,7 +551,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.REALIZATION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -569,7 +570,7 @@
 			case UML2Package.REALIZATION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.REALIZATION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.REALIZATION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.REALIZATION__NAME_EXPRESSION:
@@ -601,12 +602,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.REALIZATION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //RealizationImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReclassifyObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReclassifyObjectActionImpl.java
index 1dfbbe3..2e13f16 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReclassifyObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReclassifyObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReclassifyObjectActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ReclassifyObjectActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -147,6 +147,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableElementImpl.java
index 53b1ab7..803a9aa 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RedefinableElementImpl.java,v 1.17 2005/11/08 18:26:42 khussey Exp $
+ * $Id: RedefinableElementImpl.java,v 1.18 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -38,6 +38,7 @@
 import org.eclipse.uml2.VisibilityKind;
 
 import org.eclipse.uml2.common.util.CacheAdapter;
+//import org.eclipse.uml2.common.util.DerivedUnionEObjectEList;
 import org.eclipse.uml2.common.util.DerivedEObjectEList;
 import org.eclipse.uml2.common.util.UnionEObjectEList;
 
@@ -157,7 +158,7 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
+	 * @generated NOT
 	 */
 	public EList getRedefinitionContexts() {
 		if (redefinitionContext == null) {
@@ -166,6 +167,7 @@
 		return redefinitionContext;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -250,6 +252,7 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -435,4 +438,5 @@
 		return result.toString();
 	}
 
+
 } //RedefinableElementImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableTemplateSignatureImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableTemplateSignatureImpl.java
index 83f6b89..62ae0c1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableTemplateSignatureImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RedefinableTemplateSignatureImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RedefinableTemplateSignatureImpl.java,v 1.13 2005/11/04 22:23:02 khussey Exp $
+ * $Id: RedefinableTemplateSignatureImpl.java,v 1.14 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -139,6 +139,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -335,6 +336,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTemplateSignature_Template());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RegionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RegionImpl.java
index 74deb7e..d816592 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RegionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RegionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RegionImpl.java,v 1.17 2005/11/04 22:23:00 khussey Exp $
+ * $Id: RegionImpl.java,v 1.18 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -168,6 +168,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinitionContexts() {
+		return !getRedefinitionContexts().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public boolean isLeaf() {
 		return (eFlags & IS_LEAF_EFLAG) != 0;
 	}
@@ -389,6 +398,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -473,20 +483,20 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetRedefinitionContexts() {
-		return !getRedefinitionContexts().isEmpty();
+	public EList getRedefinedElements() {
+		return new EcoreEList.UnmodifiableEList(this, null, 0, Collections.EMPTY_LIST.toArray());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getRedefinedElements() {
-		return new EcoreEList.UnmodifiableEList(this, null, 0, Collections.EMPTY_LIST.toArray());
+	public boolean isSetRedefinedElements() {
+		return !getRedefinedElements().isEmpty();
 	}
 
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -530,6 +540,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getRegion_State());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -959,4 +970,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getRegion_Transition());
 	}
 
+
 } //RegionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RelationshipImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RelationshipImpl.java
index d28dda0..78360a1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RelationshipImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/RelationshipImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: RelationshipImpl.java,v 1.10 2005/11/04 22:22:59 khussey Exp $
+ * $Id: RelationshipImpl.java,v 1.11 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -84,6 +84,7 @@
 		return relatedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReplyActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReplyActionImpl.java
index e00134a..c9dd795 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReplyActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ReplyActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ReplyActionImpl.java,v 1.14 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ReplyActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -123,6 +123,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendObjectActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendObjectActionImpl.java
index 8b39019..a88b9cf 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendObjectActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendObjectActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SendObjectActionImpl.java,v 1.16 2005/11/04 22:23:00 khussey Exp $
+ * $Id: SendObjectActionImpl.java,v 1.17 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -115,6 +115,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -244,14 +245,6 @@
 
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetRequest() {
-		return request != null;
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -286,6 +279,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRequest() {
+		return request != null;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public EList getArguments() {
 		return new EcoreEList.UnmodifiableEList(this, UML2Package.eINSTANCE.getInvocationAction_Argument(), 0, Collections.EMPTY_LIST.toArray());
 	}
@@ -294,6 +296,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetArguments() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
@@ -603,7 +614,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.SEND_OBJECT_ACTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -662,7 +673,7 @@
 			case UML2Package.SEND_OBJECT_ACTION__LOCAL_POSTCONDITION:
 				return localPostcondition != null && !localPostcondition.isEmpty();
 			case UML2Package.SEND_OBJECT_ACTION__ARGUMENT:
-				return !getArguments().isEmpty();
+				return isSetArguments();
 			case UML2Package.SEND_OBJECT_ACTION__ON_PORT:
 				return onPort != null;
 			case UML2Package.SEND_OBJECT_ACTION__TARGET:
@@ -674,12 +685,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.SEND_OBJECT_ACTION__ARGUMENT:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //SendObjectActionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendSignalActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendSignalActionImpl.java
index 2f1850a..d4e3b16 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendSignalActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SendSignalActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SendSignalActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: SendSignalActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -114,6 +114,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SignalImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SignalImpl.java
index ebb5fb1..62cf99f 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SignalImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SignalImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SignalImpl.java,v 1.21 2005/11/04 22:23:01 khussey Exp $
+ * $Id: SignalImpl.java,v 1.22 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,6 +102,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -496,7 +497,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.SIGNAL__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -515,7 +516,7 @@
 			case UML2Package.SIGNAL__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.SIGNAL__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.SIGNAL__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.SIGNAL__NAME_EXPRESSION:
@@ -575,14 +576,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.SIGNAL__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -606,4 +599,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getSignal_OwnedAttribute());
 	}
 
+
 } //SignalImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SlotImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SlotImpl.java
index 5b36884..b3375a4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SlotImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SlotImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SlotImpl.java,v 1.11 2005/11/04 22:23:00 khussey Exp $
+ * $Id: SlotImpl.java,v 1.12 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -113,6 +113,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -261,6 +262,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getSlot_OwningInstance());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StartOwnedBehaviorActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StartOwnedBehaviorActionImpl.java
index 7f342a9..37bd9b8 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StartOwnedBehaviorActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StartOwnedBehaviorActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StartOwnedBehaviorActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: StartOwnedBehaviorActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -101,6 +101,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateImpl.java
index 96d50bd..ed111e4 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StateImpl.java,v 1.19 2005/11/04 22:23:00 khussey Exp $
+ * $Id: StateImpl.java,v 1.20 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -306,6 +306,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinitionContexts() {
+		return !getRedefinitionContexts().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public boolean isLeaf() {
 		return (eFlags & IS_LEAF_EFLAG) != 0;
 	}
@@ -356,6 +365,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -593,6 +603,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1048,6 +1059,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetOwner() {
+		return basicGetOwner() != null;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 */
 	public EList getRedefinitionContexts() {
@@ -1084,20 +1104,20 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetRedefinitionContexts() {
-		return !getRedefinitionContexts().isEmpty();
+	public EList getRedefinedElements() {
+		return new EcoreEList.UnmodifiableEList(this, null, 0, Collections.EMPTY_LIST.toArray());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getRedefinedElements() {
-		return new EcoreEList.UnmodifiableEList(this, null, 0, Collections.EMPTY_LIST.toArray());
+	public boolean isSetRedefinedElements() {
+		return !getRedefinedElements().isEmpty();
 	}
 
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1679,6 +1699,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getState_StateInvariant());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1702,4 +1723,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getState_Region());
 	}
 
+
 } //StateImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateInvariantImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateInvariantImpl.java
index 9986e90..6a530a1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateInvariantImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateInvariantImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StateInvariantImpl.java,v 1.16 2005/11/04 22:23:00 khussey Exp $
+ * $Id: StateInvariantImpl.java,v 1.17 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -107,6 +107,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -211,15 +212,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetCovereds() {
-		return covered != null && !covered.isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public Lifeline getCovered(String name) {
 		for (Iterator i = getCovereds().iterator(); i.hasNext(); ) {
 			Lifeline covered = (Lifeline) i.next();
@@ -235,6 +227,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetCovereds() {
+		return covered != null && !covered.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -447,7 +448,7 @@
 			case UML2Package.STATE_INVARIANT__NAME_EXPRESSION:
 				return nameExpression != null;
 			case UML2Package.STATE_INVARIANT__COVERED:
-				return !getCovereds().isEmpty();
+				return isSetCovereds();
 			case UML2Package.STATE_INVARIANT__GENERAL_ORDERING:
 				return generalOrdering != null && !generalOrdering.isEmpty();
 			case UML2Package.STATE_INVARIANT__ENCLOSING_INTERACTION:
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateMachineImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateMachineImpl.java
index 6cd4a24..5df8193 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateMachineImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StateMachineImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StateMachineImpl.java,v 1.29 2005/11/04 22:23:00 khussey Exp $
+ * $Id: StateMachineImpl.java,v 1.30 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -276,6 +276,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -341,6 +342,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinedElements() {
+		return !getRedefinedElements().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public EList getRedefinitionContexts() {
 		return new EcoreEList.UnmodifiableEList(this, UML2Package.eINSTANCE.getRedefinableElement_RedefinitionContext(), 0, Collections.EMPTY_LIST.toArray());
 	}
@@ -351,6 +361,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinitionContexts() {
+		return !getRedefinitionContexts().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -390,6 +409,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.STATE_MACHINE__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.STATE_MACHINE__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.STATE_MACHINE__OWNED_OPERATION:
 					return ((InternalEList)getOwnedOperations()).basicAdd(otherEnd, msgs);
 				case UML2Package.STATE_MACHINE__CONTEXT:
@@ -402,6 +423,10 @@
 					return basicSetSpecification((BehavioralFeature)otherEnd, msgs);
 				case UML2Package.STATE_MACHINE__REGION:
 					return ((InternalEList)getRegions()).basicAdd(otherEnd, msgs);
+				case UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
 				default:
 					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
 			}
@@ -411,19 +436,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.STATE_MACHINE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			case UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -498,6 +510,8 @@
 					return ((InternalEList)getRegions()).basicRemove(otherEnd, msgs);
 				case UML2Package.STATE_MACHINE__CONNECTION_POINT:
 					return ((InternalEList)getConnectionPoints()).basicRemove(otherEnd, msgs);
+				case UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
+					return eBasicSetContainer(null, UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
 				default:
 					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
 			}
@@ -505,15 +519,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT:
-				return eBasicSetContainer(null, UML2Package.STATE_MACHINE__STATE_MACHINE_REDEFINITION_CONTEXT, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1026,7 +1031,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.STATE_MACHINE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1045,7 +1050,7 @@
 			case UML2Package.STATE_MACHINE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.STATE_MACHINE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.STATE_MACHINE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.STATE_MACHINE__NAME_EXPRESSION:
@@ -1075,11 +1080,11 @@
 			case UML2Package.STATE_MACHINE__FEATURE:
 				return isSetFeatures();
 			case UML2Package.STATE_MACHINE__IS_ABSTRACT:
-				return isAbstract() != IS_ABSTRACT_EDEFAULT;
+				return isSetIsAbstract();
 			case UML2Package.STATE_MACHINE__INHERITED_MEMBER:
 				return !getInheritedMembers().isEmpty();
 			case UML2Package.STATE_MACHINE__GENERAL:
-				return !getGenerals().isEmpty();
+				return isSetGenerals();
 			case UML2Package.STATE_MACHINE__GENERALIZATION:
 				return generalization != null && !generalization.isEmpty();
 			case UML2Package.STATE_MACHINE__ATTRIBUTE:
@@ -1099,7 +1104,7 @@
 			case UML2Package.STATE_MACHINE__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.STATE_MACHINE__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.STATE_MACHINE__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.STATE_MACHINE__IMPLEMENTATION:
@@ -1109,7 +1114,7 @@
 			case UML2Package.STATE_MACHINE__OWNED_STATE_MACHINE:
 				return isSetOwnedStateMachines();
 			case UML2Package.STATE_MACHINE__OWNED_ATTRIBUTE:
-				return !getOwnedAttributes().isEmpty();
+				return isSetOwnedAttributes();
 			case UML2Package.STATE_MACHINE__PART:
 				return !getParts().isEmpty();
 			case UML2Package.STATE_MACHINE__ROLE:
@@ -1163,18 +1168,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.STATE_MACHINE__VISIBILITY:
-				return false;
-			case UML2Package.STATE_MACHINE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.STATE_MACHINE__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1202,6 +1195,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getStateMachine_ConnectionPoint());
 	}
 
+
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StereotypeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StereotypeImpl.java
index 1611e46..c089503 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StereotypeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StereotypeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StereotypeImpl.java,v 1.36 2005/11/04 22:23:01 khussey Exp $
+ * $Id: StereotypeImpl.java,v 1.37 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -16,13 +16,7 @@
 import java.util.Collections;
 import java.util.Set;
 
-import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.util.InternalEList;
 
 import org.eclipse.uml2.Extension;
 import org.eclipse.uml2.Profile;
@@ -69,27 +63,6 @@
 	}
 
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.STEREOTYPE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.STEREOTYPE__VISIBILITY:
-				return false;
-			case UML2Package.STEREOTYPE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-			case UML2Package.STEREOTYPE__OWNED_ATTRIBUTE:
-				return ownedAttribute != null && !ownedAttribute.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	// <!-- begin-custom-operations -->
 
 	/*
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StringExpressionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StringExpressionImpl.java
index cce714d..0064add 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StringExpressionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StringExpressionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StringExpressionImpl.java,v 1.11 2005/11/04 22:23:02 khussey Exp $
+ * $Id: StringExpressionImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -100,6 +100,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -208,6 +209,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getStringExpression_OwningExpression());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureActionImpl.java
index ad0aba1..970306c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuralFeatureActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: StructuralFeatureActionImpl.java,v 1.16 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -113,6 +113,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureImpl.java
index c713d6b..1d6a867 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuralFeatureImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuralFeatureImpl.java,v 1.17 2005/11/04 22:23:00 khussey Exp $
+ * $Id: StructuralFeatureImpl.java,v 1.18 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -254,6 +254,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredActivityNodeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredActivityNodeImpl.java
index 3961dde..634e78d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredActivityNodeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredActivityNodeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuredActivityNodeImpl.java,v 1.27 2005/11/04 22:22:59 khussey Exp $
+ * $Id: StructuredActivityNodeImpl.java,v 1.28 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -219,6 +219,7 @@
 			|| isSetOwnedMembers();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -452,6 +453,7 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -562,14 +564,6 @@
 		return containedNode;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetContainedNodes() {
-		return containedNode != null && !containedNode.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -588,6 +582,15 @@
 
 	/**
 	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetContainedNodes() {
+		return containedNode != null && !containedNode.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
      * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -612,14 +615,6 @@
 		return containedEdge;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetContainedEdges() {
-		return containedEdge != null && !containedEdge.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -641,6 +636,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetContainedEdges() {
+		return containedEdge != null && !containedEdge.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public ActivityEdge createContainedEdge(EClass eClass) {
 		ActivityEdge newContainedEdge = (ActivityEdge) eClass.getEPackage().getEFactoryInstance().create(eClass);
 		if (eNotificationRequired()) {
@@ -745,19 +749,18 @@
 		return false;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public Element basicGetOwner() {
-		ActivityGroup superGroup = basicGetSuperGroup();			
-		if (superGroup != null) {
-			return superGroup;
+		if (isSetSuperGroup()) {
+			return basicGetSuperGroup();
 		}
-		Activity activityGroup_activity = getActivityGroup_activity();			
-		if (activityGroup_activity != null) {
-			return activityGroup_activity;
+		if (isSetActivityGroup_activity()) {
+			return getActivityGroup_activity();
 		}
 		return super.basicGetOwner();
 	}
@@ -773,6 +776,7 @@
 			|| isSetActivityGroup_activity();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -795,10 +799,10 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
+	 * @generated NOT
 	 */
 	public boolean isSetActivity() {
-		return getActivity() != null;
+		return false;
 	}
 
 	public void setActivity(Activity newActivity) {
@@ -827,10 +831,10 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated
+	 * @generated NOT
 	 */
 	public boolean isSetActivityGroup_activity() {
-		return getActivityGroup_activity() != null;
+		return false;
 	}
 
 	/**
@@ -867,6 +871,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getStructuredActivityNode_Variable());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -895,15 +900,13 @@
 		if (eIsSet(UML2Package.eINSTANCE.getNamespace_PackageImport())) {
 			ownedElement.addAll(getPackageImports());
 		}
-		EList ownedMember = getOwnedMembers();
-		if (!ownedMember.isEmpty()) {
-			for (Iterator i = ((InternalEList) ownedMember).basicIterator(); i.hasNext(); ) {
+		if (isSetOwnedMembers()) {
+			for (Iterator i = ((InternalEList) getOwnedMembers()).basicIterator(); i.hasNext(); ) {
 				ownedElement.add(i.next());
 			}
 		}
-		EList subgroup = getSubgroups();
-		if (!subgroup.isEmpty()) {
-			for (Iterator i = ((InternalEList) subgroup).basicIterator(); i.hasNext(); ) {
+		if (isSetSubgroups()) {
+			for (Iterator i = ((InternalEList) getSubgroups()).basicIterator(); i.hasNext(); ) {
 				ownedElement.add(i.next());
 			}
 		}
@@ -942,6 +945,7 @@
 			|| isSetSubgroups();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -984,6 +988,10 @@
 					return ((InternalEList)getElementImports()).basicAdd(otherEnd, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicAdd(otherEnd, msgs);
+				case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY:
+					if (eContainer != null)
+						msgs = eBasicRemoveFromContainer(msgs);
+					return eBasicSetContainer(otherEnd, UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__VARIABLE:
 					return ((InternalEList)getVariables()).basicAdd(otherEnd, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__CONTAINED_NODE:
@@ -1000,20 +1008,6 @@
 	}
 
 	/**
-	 * @see org.eclipse.emf.ecore.impl.EObjectImpl#eDynamicInverseAdd(org.eclipse.emf.ecore.InternalEObject, int, java.lang.Class, org.eclipse.emf.common.notify.NotificationChain)
-	 */
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY :
-				if (eContainer != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return eBasicSetContainer(otherEnd, UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -1057,6 +1051,8 @@
 					return ((InternalEList)getElementImports()).basicRemove(otherEnd, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__PACKAGE_IMPORT:
 					return ((InternalEList)getPackageImports()).basicRemove(otherEnd, msgs);
+				case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY:
+					return eBasicSetContainer(null, UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__VARIABLE:
 					return ((InternalEList)getVariables()).basicRemove(otherEnd, msgs);
 				case UML2Package.STRUCTURED_ACTIVITY_NODE__CONTAINED_NODE:
@@ -1070,15 +1066,6 @@
 		return eBasicSetContainer(null, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseRemove(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return eBasicSetContainer(null, UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY, msgs);
-			default :
-				return super.eDynamicInverseRemove(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1383,7 +1370,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.STRUCTURED_ACTIVITY_NODE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -1418,7 +1405,7 @@
 			case UML2Package.STRUCTURED_ACTIVITY_NODE__IN_GROUP:
 				return isSetInGroups();
 			case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY:
-				return getActivity() != null;
+				return isSetActivity();
 			case UML2Package.STRUCTURED_ACTIVITY_NODE__REDEFINED_ELEMENT:
 				return isSetRedefinedElements();
 			case UML2Package.STRUCTURED_ACTIVITY_NODE__IN_STRUCTURED_NODE:
@@ -1467,16 +1454,6 @@
 		return eDynamicIsSet(eFeature);
 	}
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY:
-				return false;
-			case UML2Package.STRUCTURED_ACTIVITY_NODE__ACTIVITY_GROUP_ACTIVITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1557,9 +1534,8 @@
 				member.add(i.next());
 			}
 		}
-		EList ownedMember = getOwnedMembers();
-		if (!ownedMember.isEmpty()) {
-			for (Iterator i = ((InternalEList) ownedMember).basicIterator(); i.hasNext(); ) {
+		if (isSetOwnedMembers()) {
+			for (Iterator i = ((InternalEList) getOwnedMembers()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
 		}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredClassifierImpl.java
index cfa48ff..19b04ac 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/StructuredClassifierImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: StructuredClassifierImpl.java,v 1.24 2005/11/04 22:23:02 khussey Exp $
+ * $Id: StructuredClassifierImpl.java,v 1.25 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -234,6 +234,7 @@
 		return role;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -270,6 +271,7 @@
 		return attribute;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -292,6 +294,7 @@
 		return feature;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -329,6 +332,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_OwnedConnector());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -336,7 +340,7 @@
 	 */
 	protected EList getMembersHelper(EList member) {
 		super.getMembersHelper(member);
-		if (eIsSet(UML2Package.eINSTANCE.getStructuredClassifier_Role())) {
+		if (isSetRoles()) {
 			for (Iterator i = ((InternalEList) getRoles()).basicIterator(); i.hasNext(); ) {
 				member.add(i.next());
 			}
@@ -354,6 +358,7 @@
 			|| isSetRoles();
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -754,7 +759,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.STRUCTURED_CLASSIFIER__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -773,7 +778,7 @@
 			case UML2Package.STRUCTURED_CLASSIFIER__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.STRUCTURED_CLASSIFIER__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.STRUCTURED_CLASSIFIER__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.STRUCTURED_CLASSIFIER__NAME_EXPRESSION:
@@ -839,12 +844,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.STRUCTURED_CLASSIFIER__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //StructuredClassifierImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SubstitutionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SubstitutionImpl.java
index d5bf2ae..501c89d 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SubstitutionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/SubstitutionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: SubstitutionImpl.java,v 1.16 2005/11/04 22:23:01 khussey Exp $
+ * $Id: SubstitutionImpl.java,v 1.17 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -552,7 +552,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.SUBSTITUTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -571,7 +571,7 @@
 			case UML2Package.SUBSTITUTION__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.SUBSTITUTION__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.SUBSTITUTION__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.SUBSTITUTION__NAME_EXPRESSION:
@@ -607,12 +607,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.SUBSTITUTION__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //SubstitutionImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateBindingImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateBindingImpl.java
index 7d8bb2e..831ebd1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateBindingImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateBindingImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateBindingImpl.java,v 1.13 2005/11/04 22:23:00 khussey Exp $
+ * $Id: TemplateBindingImpl.java,v 1.14 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -115,6 +115,7 @@
 		return source;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -137,6 +138,7 @@
 		return target;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -159,6 +161,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -307,6 +310,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTemplateBinding_BoundElement());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterImpl.java
index 0dd5e43..e0ebe55 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateParameterImpl.java,v 1.16 2005/11/04 22:23:01 khussey Exp $
+ * $Id: TemplateParameterImpl.java,v 1.17 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -132,6 +132,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -434,6 +435,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTemplateParameter_Signature());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterSubstitutionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterSubstitutionImpl.java
index 6dc4f8a..6500bf1 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterSubstitutionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateParameterSubstitutionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateParameterSubstitutionImpl.java,v 1.13 2005/11/04 22:23:01 khussey Exp $
+ * $Id: TemplateParameterSubstitutionImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -124,6 +124,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -270,6 +271,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTemplateParameterSubstitution_TemplateBinding());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateSignatureImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateSignatureImpl.java
index 8ccbedb..11654e6 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateSignatureImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateSignatureImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateSignatureImpl.java,v 1.11 2005/11/04 22:23:02 khussey Exp $
+ * $Id: TemplateSignatureImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -136,6 +136,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -332,6 +333,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTemplateSignature_Template());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableClassifierImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableClassifierImpl.java
index ad8b304..bb736b0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableClassifierImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableClassifierImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateableClassifierImpl.java,v 1.20 2005/11/04 22:22:59 khussey Exp $
+ * $Id: TemplateableClassifierImpl.java,v 1.21 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.TemplateableClassifier;
 import org.eclipse.uml2.UML2Package;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.TEMPLATEABLE_CLASSIFIER__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //TemplateableClassifierImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableElementImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableElementImpl.java
index 169d59d..e510fb9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableElementImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TemplateableElementImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TemplateableElementImpl.java,v 1.13 2005/11/04 22:22:59 khussey Exp $
+ * $Id: TemplateableElementImpl.java,v 1.14 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -115,6 +115,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TestIdentityActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TestIdentityActionImpl.java
index 278cbff..47aa2ea 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TestIdentityActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TestIdentityActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TestIdentityActionImpl.java,v 1.15 2005/11/04 22:23:01 khussey Exp $
+ * $Id: TestIdentityActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -125,6 +125,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -148,6 +149,7 @@
 		return output;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeConstraintImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeConstraintImpl.java
index 9c2c30b..ae7e553 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeConstraintImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeConstraintImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TimeConstraintImpl.java,v 1.11 2005/11/04 22:23:02 khussey Exp $
+ * $Id: TimeConstraintImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -169,7 +169,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.TIME_CONSTRAINT__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -188,7 +188,7 @@
 			case UML2Package.TIME_CONSTRAINT__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.TIME_CONSTRAINT__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.TIME_CONSTRAINT__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.TIME_CONSTRAINT__NAME_EXPRESSION:
@@ -204,7 +204,7 @@
 			case UML2Package.TIME_CONSTRAINT__NAMESPACE:
 				return isSetNamespace();
 			case UML2Package.TIME_CONSTRAINT__SPECIFICATION:
-				return getSpecification() != null;
+				return isSetSpecification();
 			case UML2Package.TIME_CONSTRAINT__CONSTRAINED_ELEMENT:
 				return constrainedElement != null && !constrainedElement.isEmpty();
 		}
@@ -212,12 +212,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.TIME_CONSTRAINT__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //TimeConstraintImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeIntervalImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeIntervalImpl.java
index 4f56ffb..dc75a26 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeIntervalImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeIntervalImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TimeIntervalImpl.java,v 1.10 2005/11/04 22:23:00 khussey Exp $
+ * $Id: TimeIntervalImpl.java,v 1.11 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -75,14 +75,6 @@
 		return max;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetMaxes() {
-		return max != null && !max.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -104,11 +96,8 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList getMins() {
-		if (min == null) {
-			min = new EObjectResolvingEList(TimeExpression.class, this, UML2Package.TIME_INTERVAL__MIN);
-		}
-		return min;
+	public boolean isSetMaxes() {
+		return max != null && !max.isEmpty();
 	}
 
 	/**
@@ -116,10 +105,14 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetMins() {
-		return min != null && !min.isEmpty();
+	public EList getMins() {
+		if (min == null) {
+			min = new EObjectResolvingEList(TimeExpression.class, this, UML2Package.TIME_INTERVAL__MIN);
+		}
+		return min;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -140,6 +133,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetMins() {
+		return min != null && !min.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.TIME_INTERVAL__EANNOTATIONS:
@@ -217,9 +219,9 @@
 			case UML2Package.TIME_INTERVAL__OWNING_PARAMETER:
 				return getOwningParameter() != null;
 			case UML2Package.TIME_INTERVAL__MIN:
-				return !getMins().isEmpty();
+				return isSetMins();
 			case UML2Package.TIME_INTERVAL__MAX:
-				return !getMaxes().isEmpty();
+				return isSetMaxes();
 		}
 		return eDynamicIsSet(eFeature);
 	}
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeObservationActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeObservationActionImpl.java
index d6f7f07..ef1d2bf 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeObservationActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeObservationActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TimeObservationActionImpl.java,v 1.14 2005/11/04 22:23:02 khussey Exp $
+ * $Id: TimeObservationActionImpl.java,v 1.15 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,14 +102,6 @@
 		return now;
 	}
 
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetNows() {
-		return now != null && !now.isEmpty();
-	}
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -129,6 +121,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetNows() {
+		return now != null && !now.isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated NOT
 	 * @deprecated Use #createNow() instead.
 	 */
@@ -186,6 +187,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	public boolean isSetValue() {
+		return false;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
@@ -495,7 +505,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.TIME_OBSERVATION_ACTION__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -558,7 +568,7 @@
 			case UML2Package.TIME_OBSERVATION_ACTION__OBJECT:
 				return object != null;
 			case UML2Package.TIME_OBSERVATION_ACTION__VALUE:
-				return getValue() != null;
+				return isSetValue();
 			case UML2Package.TIME_OBSERVATION_ACTION__NOW:
 				return isSetNows();
 		}
@@ -566,14 +576,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.TIME_OBSERVATION_ACTION__VALUE:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	public EList getInputs() {
 		if (input == null) {
 			input = new DerivedUnionEObjectEList(InputPin.class, this, UML2Package.TIME_OBSERVATION_ACTION__INPUT, new EStructuralFeature[] {UML2Package.eINSTANCE.getStructuralFeatureAction_Object(), UML2Package.eINSTANCE.getTimeObservationAction_Now()});
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeTriggerImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeTriggerImpl.java
index ba7835e..288f875 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeTriggerImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TimeTriggerImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TimeTriggerImpl.java,v 1.14 2005/11/04 22:22:59 khussey Exp $
+ * $Id: TimeTriggerImpl.java,v 1.15 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -121,6 +121,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TransitionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TransitionImpl.java
index 3a62ff5..623a60a 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TransitionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TransitionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TransitionImpl.java,v 1.17 2005/11/04 22:23:00 khussey Exp $
+ * $Id: TransitionImpl.java,v 1.18 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -193,6 +193,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -425,6 +426,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -650,15 +652,6 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean isSetRedefinitionContexts() {
-		return !getRedefinitionContexts().isEmpty();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
     public Classifier getRedefinitionContext(String name) {
 		for (Iterator i = getRedefinitionContexts().iterator(); i.hasNext(); ) {
 			Classifier redefinitionContext = (Classifier) i.next();
@@ -674,6 +667,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinitionContexts() {
+		return !getRedefinitionContexts().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Element basicGetOwner() {
 		Region container = getContainer();			
 		if (container != null) {
@@ -692,6 +694,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getTransition_Container());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -707,6 +710,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetRedefinedElements() {
+		return !getRedefinedElements().isEmpty();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TypeImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TypeImpl.java
index 9ec7457..4cc0e5c 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TypeImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/TypeImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: TypeImpl.java,v 1.13 2005/11/04 22:23:00 khussey Exp $
+ * $Id: TypeImpl.java,v 1.14 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -101,6 +101,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getType_Package());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -149,7 +150,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.TYPE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -168,7 +169,7 @@
 			case UML2Package.TYPE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.TYPE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.TYPE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.TYPE__NAME_EXPRESSION:
@@ -186,14 +187,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.TYPE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	// <!-- begin-custom-operations -->
 
 	/* (non-Javadoc)
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UML2PackageImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UML2PackageImpl.java
index 607d941..24bf4c3 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UML2PackageImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UML2PackageImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: UML2PackageImpl.java,v 1.24 2005/11/04 22:23:00 khussey Exp $
+ * $Id: UML2PackageImpl.java,v 1.25 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -10886,13 +10886,13 @@
 		initEReference(getBehavioredClassifier_ClassifierBehavior(), this.getBehavior(), null, "classifierBehavior", null, 0, 1, BehavioredClassifier.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
 		initEReference(getBehavioredClassifier_Implementation(), this.getImplementation(), this.getImplementation_ImplementingClassifier(), "implementation", null, 0, -1, BehavioredClassifier.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 		initEReference(getBehavioredClassifier_OwnedTrigger(), this.getTrigger(), null, "ownedTrigger", null, 0, -1, BehavioredClassifier.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
-		initEReference(getBehavioredClassifier_OwnedStateMachine(), this.getStateMachine(), this.getStateMachine_StateMachine_redefinitionContext(), "ownedStateMachine", null, 0, -1, BehavioredClassifier.class, !IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEReference(getBehavioredClassifier_OwnedStateMachine(), this.getStateMachine(), this.getStateMachine_StateMachine_redefinitionContext(), "ownedStateMachine", null, 0, -1, BehavioredClassifier.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 
 		initEClass(activityEClass, Activity.class, "Activity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
 		initEAttribute(getActivity_Body(), this.getString(), "body", "", 0, 1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
 		initEAttribute(getActivity_Language(), this.getString(), "language", "", 0, 1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
 		initEReference(getActivity_Edge(), this.getActivityEdge(), this.getActivityEdge_Activity(), "edge", null, 0, -1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
-		initEReference(getActivity_Group(), this.getActivityGroup(), this.getActivityGroup_ActivityGroup_activity(), "group", null, 0, -1, Activity.class, !IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEReference(getActivity_Group(), this.getActivityGroup(), this.getActivityGroup_ActivityGroup_activity(), "group", null, 0, -1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 		initEReference(getActivity_Node(), this.getActivityNode(), this.getActivityNode_Activity(), "node", null, 0, -1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 		initEReference(getActivity_Action(), this.getAction(), null, "action", null, 0, -1, Activity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
 		initEReference(getActivity_StructuredNode(), this.getStructuredActivityNode(), null, "structuredNode", null, 0, -1, Activity.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
@@ -10971,7 +10971,7 @@
 
 		initEClass(activityGroupEClass, ActivityGroup.class, "ActivityGroup", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
 		initEReference(getActivityGroup_SuperGroup(), this.getActivityGroup(), null, "superGroup", null, 0, 1, ActivityGroup.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
-		initEReference(getActivityGroup_ActivityGroup_activity(), this.getActivity(), this.getActivity_Group(), "activityGroup_activity", null, 0, 1, ActivityGroup.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getActivityGroup_ActivityGroup_activity(), this.getActivity(), this.getActivity_Group(), "activityGroup_activity", null, 0, 1, ActivityGroup.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
 
 		initEClass(activityNodeEClass, ActivityNode.class, "ActivityNode", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
 		initEReference(getActivityNode_Outgoing(), this.getActivityEdge(), this.getActivityEdge_Source(), "outgoing", null, 0, -1, ActivityNode.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
@@ -11322,7 +11322,7 @@
 		initEReference(getStateMachine_Region(), this.getRegion(), this.getRegion_StateMachine(), "region", null, 1, -1, StateMachine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 		initEReference(getStateMachine_ConnectionPoint(), this.getPseudostate(), null, "connectionPoint", null, 0, -1, StateMachine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
 		initEReference(getStateMachine_ExtendedStateMachine(), this.getStateMachine(), null, "extendedStateMachine", null, 0, 1, StateMachine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
-		initEReference(getStateMachine_StateMachine_redefinitionContext(), this.getBehavioredClassifier(), this.getBehavioredClassifier_OwnedStateMachine(), "stateMachine_redefinitionContext", null, 0, 1, StateMachine.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getStateMachine_StateMachine_redefinitionContext(), this.getBehavioredClassifier(), this.getBehavioredClassifier_OwnedStateMachine(), "stateMachine_redefinitionContext", null, 0, 1, StateMachine.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
 
 		initEClass(regionEClass, Region.class, "Region", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
 		initEReference(getRegion_Subvertex(), this.getVertex(), this.getVertex_Container(), "subvertex", null, 0, -1, Region.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UsageImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UsageImpl.java
index c2f04ed..4b83fe0 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UsageImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UsageImpl.java
@@ -8,12 +8,11 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: UsageImpl.java,v 1.10 2005/11/04 22:23:00 khussey Exp $
+ * $Id: UsageImpl.java,v 1.11 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.uml2.UML2Package;
 import org.eclipse.uml2.Usage;
 
@@ -53,12 +52,4 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.USAGE__VISIBILITY:
-				return false;
-		}
-		return eIsSetGen(eFeature);
-	}
-
 } //UsageImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UseCaseImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UseCaseImpl.java
index 795d5f0..4d4dbc9 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UseCaseImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/UseCaseImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: UseCaseImpl.java,v 1.21 2005/11/04 22:23:01 khussey Exp $
+ * $Id: UseCaseImpl.java,v 1.22 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -368,6 +368,8 @@
 					return ((InternalEList)getOwnedBehaviors()).basicAdd(otherEnd, msgs);
 				case UML2Package.USE_CASE__IMPLEMENTATION:
 					return ((InternalEList)getImplementations()).basicAdd(otherEnd, msgs);
+				case UML2Package.USE_CASE__OWNED_STATE_MACHINE:
+					return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
 				case UML2Package.USE_CASE__INCLUDE:
 					return ((InternalEList)getIncludes()).basicAdd(otherEnd, msgs);
 				case UML2Package.USE_CASE__EXTEND:
@@ -385,15 +387,6 @@
 		return eBasicSetContainer(otherEnd, featureID, msgs);
 	}
 
-	public NotificationChain eDynamicInverseAdd(InternalEObject otherEnd, int featureID, Class inverseClass, NotificationChain msgs) {
-		switch (eDerivedStructuralFeatureID(featureID, inverseClass)) {
-			case UML2Package.USE_CASE__OWNED_STATE_MACHINE:
-				return ((InternalEList)getOwnedStateMachines()).basicAdd(otherEnd, msgs);
-			default :
-				return super.eDynamicInverseAdd(otherEnd, featureID, inverseClass, msgs);
-		}
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -807,7 +800,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
+	public boolean eIsSet(EStructuralFeature eFeature) {
 		switch (eDerivedStructuralFeatureID(eFeature)) {
 			case UML2Package.USE_CASE__EANNOTATIONS:
 				return eAnnotations != null && !eAnnotations.isEmpty();
@@ -826,7 +819,7 @@
 			case UML2Package.USE_CASE__QUALIFIED_NAME:
 				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
 			case UML2Package.USE_CASE__VISIBILITY:
-				return getVisibility() != VISIBILITY_EDEFAULT;
+				return isSetVisibility();
 			case UML2Package.USE_CASE__CLIENT_DEPENDENCY:
 				return clientDependency != null && !clientDependency.isEmpty();
 			case UML2Package.USE_CASE__NAME_EXPRESSION:
@@ -880,7 +873,7 @@
 			case UML2Package.USE_CASE__OCCURRENCE:
 				return occurrence != null && !occurrence.isEmpty();
 			case UML2Package.USE_CASE__OWNED_BEHAVIOR:
-				return !getOwnedBehaviors().isEmpty();
+				return isSetOwnedBehaviors();
 			case UML2Package.USE_CASE__CLASSIFIER_BEHAVIOR:
 				return classifierBehavior != null;
 			case UML2Package.USE_CASE__IMPLEMENTATION:
@@ -902,16 +895,6 @@
 	}
 
 
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case UML2Package.USE_CASE__VISIBILITY:
-				return false;
-			case UML2Package.USE_CASE__OWNED_BEHAVIOR:
-				return ownedBehavior != null && !ownedBehavior.isEmpty();
-		}
-		return eIsSetGen(eFeature);
-	}
-
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -943,4 +926,5 @@
 			|| eIsSet(UML2Package.eINSTANCE.getUseCase_ExtensionPoint());
 	}
 
+
 } //UseCaseImpl
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ValueSpecificationImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ValueSpecificationImpl.java
index 6a44953..dc1affa 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ValueSpecificationImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/ValueSpecificationImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: ValueSpecificationImpl.java,v 1.11 2005/11/04 22:23:01 khussey Exp $
+ * $Id: ValueSpecificationImpl.java,v 1.12 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -211,6 +211,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getParameterableElement_OwningParameter());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VariableImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VariableImpl.java
index 06774e5..c464398 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VariableImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VariableImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: VariableImpl.java,v 1.14 2005/11/04 22:23:00 khussey Exp $
+ * $Id: VariableImpl.java,v 1.15 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -237,6 +237,7 @@
 		return ownedElement;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -596,6 +597,7 @@
 			|| eIsSet(UML2Package.eINSTANCE.getVariable_Scope());
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VertexImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VertexImpl.java
index f2fa76f..22b5012 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VertexImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/VertexImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: VertexImpl.java,v 1.10 2005/11/04 22:23:02 khussey Exp $
+ * $Id: VertexImpl.java,v 1.11 2005/11/09 22:53:09 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -128,6 +128,7 @@
 
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -221,6 +222,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean isSetOwner() {
+		return basicGetOwner() != null;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteStructuralFeatureActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteStructuralFeatureActionImpl.java
index e7b42c9..219c613 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteStructuralFeatureActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteStructuralFeatureActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: WriteStructuralFeatureActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: WriteStructuralFeatureActionImpl.java,v 1.16 2005/11/09 22:53:08 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,6 +102,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteVariableActionImpl.java b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteVariableActionImpl.java
index 8d21d47..51cf414 100644
--- a/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteVariableActionImpl.java
+++ b/deprecated/plugins/org.eclipse.uml2/src/org/eclipse/uml2/impl/WriteVariableActionImpl.java
@@ -8,7 +8,7 @@
  * Contributors:
  *   IBM - initial API and implementation
  *
- * $Id: WriteVariableActionImpl.java,v 1.15 2005/11/04 22:23:00 khussey Exp $
+ * $Id: WriteVariableActionImpl.java,v 1.16 2005/11/09 22:53:07 khussey Exp $
  */
 package org.eclipse.uml2.impl;
 
@@ -102,6 +102,7 @@
 		return input;
 	}
 
+
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
