diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/META-INF/MANIFEST.MF b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/META-INF/MANIFEST.MF
index fc03d68..d93dbba 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/META-INF/MANIFEST.MF
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/META-INF/MANIFEST.MF
@@ -2,10 +2,12 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.mdht.uml.hl7.datatypes;singleton:=true
+Automatic-Module-Name: org.eclipse.mdht.uml.hl7.datatypes
 Bundle-Version: 3.0.0.qualifier
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
 Export-Package: org.eclipse.mdht.uml.hl7.datatypes,
  org.eclipse.mdht.uml.hl7.datatypes.impl,
  org.eclipse.mdht.uml.hl7.datatypes.operations,
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.ecore b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.ecore
index 929faca..7c2aa8e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.ecore
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.ecore
@@ -99,6 +99,7 @@
   <eClassifiers xsi:type="ecore:EClass" name="TEL" eSuperTypes="#//URL">
     <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
       <details key="kind" value="mixed"/>
+      <details key="name" value=""/>
     </eAnnotations>
     <eOperations name="getText" ordered="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//String"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="useablePeriod" ordered="false"
@@ -118,6 +119,7 @@
         eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EFeatureMapEntry">
       <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
         <details key="name" value="mixed"/>
+        <details key="namespace" value=""/>
         <details key="kind" value="elementWildcard"/>
       </eAnnotations>
     </eStructuralFeatures>
@@ -2458,4 +2460,100 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="SXCM_REAL" eSuperTypes="#//REAL">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="operator" ordered="false"
+        eType="ecore:EEnum ../../org.eclipse.mdht.uml.hl7.vocab/model/vocab.ecore#//SetOperator"
+        defaultValueLiteral="I"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IVXB_REAL" eSuperTypes="#//REAL">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="inclusive" ordered="false"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBooleanObject"
+        defaultValueLiteral="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IVL_REAL" eSuperTypes="#//SXCM_REAL">
+    <eOperations name="optionsContainingLow" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eAnnotations source="http://www.eclipse.org/uml2/1.1.0/GenModel">
+        <details key="body" value="not self.low.oclIsUndefined() implies self.center.oclIsUndefined() and (self.width.oclIsUndefined() or self.high.oclIsUndefined())"/>
+      </eAnnotations>
+      <eParameters name="diagnostics" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDiagnosticChain">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The chain of diagnostics to which problems are to be appended."/>
+        </eAnnotations>
+      </eParameters>
+      <eParameters name="context">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The cache of context-specific information."/>
+        </eAnnotations>
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EMap">
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+        </eGenericType>
+      </eParameters>
+    </eOperations>
+    <eOperations name="optionsContainingCenter" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eAnnotations source="http://www.eclipse.org/uml2/1.1.0/GenModel">
+        <details key="body" value="not self.center.oclIsUndefined() implies self.high.oclIsUndefined() and self.low.oclIsUndefined()"/>
+      </eAnnotations>
+      <eParameters name="diagnostics" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDiagnosticChain">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The chain of diagnostics to which problems are to be appended."/>
+        </eAnnotations>
+      </eParameters>
+      <eParameters name="context">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The cache of context-specific information."/>
+        </eAnnotations>
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EMap">
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+        </eGenericType>
+      </eParameters>
+    </eOperations>
+    <eOperations name="optionsContainingHigh" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eAnnotations source="http://www.eclipse.org/uml2/1.1.0/GenModel">
+        <details key="body" value="not self.high.oclIsUndefined() implies (self.low.oclIsUndefined() and self.center.oclIsUndefined() and self.width.oclIsUndefined()) or ((not self.low.oclIsUndefined()) and self.width.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.width.oclIsUndefined()) and self.low.oclIsUndefined() and self.center.oclIsUndefined())"/>
+      </eAnnotations>
+      <eParameters name="diagnostics" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDiagnosticChain">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The chain of diagnostics to which problems are to be appended."/>
+        </eAnnotations>
+      </eParameters>
+      <eParameters name="context">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The cache of context-specific information."/>
+        </eAnnotations>
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EMap">
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+        </eGenericType>
+      </eParameters>
+    </eOperations>
+    <eOperations name="optionsContainingWidth" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eAnnotations source="http://www.eclipse.org/uml2/1.1.0/GenModel">
+        <details key="body" value="not self.width.oclIsUndefined() implies ((not self.low.oclIsUndefined()) and self.center.oclIsUndefined() and self.high.oclIsUndefined()) or (self.low.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.center.oclIsUndefined()) and self.low.oclIsUndefined() and self.high.oclIsUndefined())"/>
+      </eAnnotations>
+      <eParameters name="diagnostics" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDiagnosticChain">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The chain of diagnostics to which problems are to be appended."/>
+        </eAnnotations>
+      </eParameters>
+      <eParameters name="context">
+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+          <details key="documentation" value="The cache of context-specific information."/>
+        </eAnnotations>
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EMap">
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+          <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+        </eGenericType>
+      </eParameters>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="low" ordered="false" eType="#//IVL_REAL"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="center" ordered="false"
+        eType="#//REAL" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="high" ordered="false" eType="#//IVL_REAL"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="width" ordered="false"
+        eType="#//REAL" containment="true"/>
+  </eClassifiers>
 </ecore:EPackage>
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.genmodel b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.genmodel
index 2ee4831..7147af5 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.genmodel
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.genmodel
@@ -775,5 +775,37 @@
       <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
           createChild="true" ecoreFeature="ecore:EReference datatypes.ecore#//EIVL_TS/offset"/>
     </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="datatypes.ecore#//SXCM_REAL">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute datatypes.ecore#//SXCM_REAL/operator"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="datatypes.ecore#//IVXB_REAL">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute datatypes.ecore#//IVXB_REAL/inclusive"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="datatypes.ecore#//IVL_REAL">
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference datatypes.ecore#//IVL_REAL/low"/>
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference datatypes.ecore#//IVL_REAL/center"/>
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference datatypes.ecore#//IVL_REAL/high"/>
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference datatypes.ecore#//IVL_REAL/width"/>
+      <genOperations xsi:type="genmodel:GenOperation" ecoreOperation="datatypes.ecore#//IVL_REAL/optionsContainingLow">
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingLow/diagnostics"/>
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingLow/context"/>
+      </genOperations>
+      <genOperations xsi:type="genmodel:GenOperation" ecoreOperation="datatypes.ecore#//IVL_REAL/optionsContainingCenter">
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingCenter/diagnostics"/>
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingCenter/context"/>
+      </genOperations>
+      <genOperations xsi:type="genmodel:GenOperation" ecoreOperation="datatypes.ecore#//IVL_REAL/optionsContainingHigh">
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingHigh/diagnostics"/>
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingHigh/context"/>
+      </genOperations>
+      <genOperations xsi:type="genmodel:GenOperation" ecoreOperation="datatypes.ecore#//IVL_REAL/optionsContainingWidth">
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingWidth/diagnostics"/>
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="datatypes.ecore#//IVL_REAL/optionsContainingWidth/context"/>
+      </genOperations>
+    </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.uml b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.uml
index 19da14f..df98112 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.uml
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/model/datatypes.uml
@@ -1500,6 +1500,72 @@
     <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_d4N5sEQ3EeCldOpAaJlPmA" name="stType"/>
     <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_WswmEETbEeC_V4iAGO_Ujg" name="csType"/>
     <packagedElement xmi:type="uml:PrimitiveType" xmi:id="_CWZPMEWyEeC7E8_5Rmjcog" name="tsType"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_k4LEYPbgEeup8bAQnVvUVg" name="SXCM_REAL">
+      <generalization xmi:id="_k4LEYfbgEeup8bAQnVvUVg" general="_oSKNAD53Ed6cla2oXsPtlA"/>
+      <ownedAttribute xmi:id="_k4LEYvbgEeup8bAQnVvUVg" name="operator" visibility="private">
+        <type xmi:type="uml:Enumeration" href="pathmap://VOCAB_MODEL/vocab.uml#__zFABkDcEd6xYZuu1VKCVw"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_k4LEY_bgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_k4LEZPbgEeup8bAQnVvUVg" value="1"/>
+        <defaultValue xmi:type="uml:InstanceValue" xmi:id="_k4LEZfbgEeup8bAQnVvUVg" name="I">
+          <type xmi:type="uml:Enumeration" href="pathmap://VOCAB_MODEL/vocab.uml#__zFABkDcEd6xYZuu1VKCVw"/>
+          <instance xmi:type="uml:EnumerationLiteral" href="pathmap://VOCAB_MODEL/vocab.uml#__zFACkDcEd6xYZuu1VKCVw"/>
+        </defaultValue>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_1PYjYPbgEeup8bAQnVvUVg" name="IVXB_REAL">
+      <generalization xmi:id="_1PYjYfbgEeup8bAQnVvUVg" general="_oSKNAD53Ed6cla2oXsPtlA"/>
+      <ownedAttribute xmi:id="_1PYjYvbgEeup8bAQnVvUVg" name="inclusive" visibility="private">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EBooleanObject"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_1PYjY_bgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_1PYjZPbgEeup8bAQnVvUVg" value="1"/>
+        <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_1PYjZfbgEeup8bAQnVvUVg" value="true">
+          <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EBooleanObject"/>
+        </defaultValue>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_66baoPbgEeup8bAQnVvUVg" name="IVL_REAL">
+      <ownedRule xmi:id="_66baofbgEeup8bAQnVvUVg" name="optionsContainingLow" constrainedElement="_66baoPbgEeup8bAQnVvUVg">
+        <specification xmi:type="uml:OpaqueExpression" xmi:id="_66baovbgEeup8bAQnVvUVg">
+          <language>OCL</language>
+          <body>not self.low.oclIsUndefined() implies self.center.oclIsUndefined() and (self.width.oclIsUndefined() or self.high.oclIsUndefined())</body>
+        </specification>
+      </ownedRule>
+      <ownedRule xmi:id="_66bao_bgEeup8bAQnVvUVg" name="optionsContainingCenter" constrainedElement="_66baoPbgEeup8bAQnVvUVg">
+        <specification xmi:type="uml:OpaqueExpression" xmi:id="_66bapPbgEeup8bAQnVvUVg">
+          <language>OCL</language>
+          <body>not self.center.oclIsUndefined() implies self.high.oclIsUndefined() and self.low.oclIsUndefined()</body>
+        </specification>
+      </ownedRule>
+      <ownedRule xmi:id="_66bapfbgEeup8bAQnVvUVg" name="optionsContainingHigh" constrainedElement="_66baoPbgEeup8bAQnVvUVg">
+        <specification xmi:type="uml:OpaqueExpression" xmi:id="_66bapvbgEeup8bAQnVvUVg">
+          <language>OCL</language>
+          <body>not self.high.oclIsUndefined() implies (self.low.oclIsUndefined() and self.center.oclIsUndefined() and self.width.oclIsUndefined()) or ((not self.low.oclIsUndefined()) and self.width.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.width.oclIsUndefined()) and self.low.oclIsUndefined() and self.center.oclIsUndefined())</body>
+        </specification>
+      </ownedRule>
+      <ownedRule xmi:id="_66bap_bgEeup8bAQnVvUVg" name="optionsContainingWidth" constrainedElement="_66baoPbgEeup8bAQnVvUVg">
+        <specification xmi:type="uml:OpaqueExpression" xmi:id="_66baqPbgEeup8bAQnVvUVg">
+          <language>OCL</language>
+          <body>not self.width.oclIsUndefined() implies ((not self.low.oclIsUndefined()) and self.center.oclIsUndefined() and self.high.oclIsUndefined()) or (self.low.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.center.oclIsUndefined()) and self.low.oclIsUndefined() and self.high.oclIsUndefined())</body>
+        </specification>
+      </ownedRule>
+      <generalization xmi:id="_66baqfbgEeup8bAQnVvUVg" general="_k4LEYPbgEeup8bAQnVvUVg"/>
+      <ownedAttribute xmi:id="_66baqvbgEeup8bAQnVvUVg" name="low" visibility="private" type="_66baoPbgEeup8bAQnVvUVg" aggregation="composite">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_66baq_bgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_66barPbgEeup8bAQnVvUVg" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:id="_66barfbgEeup8bAQnVvUVg" name="center" visibility="private" type="_oSKNAD53Ed6cla2oXsPtlA" aggregation="composite">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_66barvbgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_66bar_bgEeup8bAQnVvUVg" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:id="_66basPbgEeup8bAQnVvUVg" name="high" visibility="private" type="_66baoPbgEeup8bAQnVvUVg" aggregation="composite">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_66basfbgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_66basvbgEeup8bAQnVvUVg" value="1"/>
+      </ownedAttribute>
+      <ownedAttribute xmi:id="_66bas_bgEeup8bAQnVvUVg" name="width" visibility="private" type="_oSKNAD53Ed6cla2oXsPtlA" aggregation="composite">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_66batPbgEeup8bAQnVvUVg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_66batfbgEeup8bAQnVvUVg" value="1"/>
+      </ownedAttribute>
+    </packagedElement>
     <profileApplication xmi:id="_dltfgDxVEd6JwqSGecoePg">
       <eAnnotations xmi:id="_dl2pcDxVEd6JwqSGecoePg" source="http://www.eclipse.org/uml2/2.0.0/UML">
         <references xmi:type="ecore:EPackage" href="pathmap://UML_PROFILES/Ecore.profile.uml#_z1OFcHjqEdy8S4Cr8Rc_NA"/>
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/BinaryDataEncoding.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/BinaryDataEncoding.java
index fa19a40..3a423f9 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/BinaryDataEncoding.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/BinaryDataEncoding.java
@@ -184,6 +184,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public int getValue() {
 		return value;
 	}
@@ -193,6 +194,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getName() {
 		return name;
 	}
@@ -202,6 +204,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getLiteral() {
 		return literal;
 	}
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesFactory.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesFactory.java
index e3c9e4d..e36fe0f 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesFactory.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesFactory.java
@@ -441,6 +441,33 @@
 	EIVL_TS createEIVL_TS();
 
 	/**
+	 * Returns a new object of class '<em>SXCM REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>SXCM REAL</em>'.
+	 * @generated
+	 */
+	SXCM_REAL createSXCM_REAL();
+
+	/**
+	 * Returns a new object of class '<em>IVXB REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>IVXB REAL</em>'.
+	 * @generated
+	 */
+	IVXB_REAL createIVXB_REAL();
+
+	/**
+	 * Returns a new object of class '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>IVL REAL</em>'.
+	 * @generated
+	 */
+	IVL_REAL createIVL_REAL();
+
+	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesPackage.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesPackage.java
index db3eab0..ea60925 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesPackage.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/DatatypesPackage.java
@@ -3729,6 +3729,180 @@
 	int EIVL_TS_FEATURE_COUNT = SXCM_TS_FEATURE_COUNT + 2;
 
 	/**
+	 * The meta object id for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.SXCM_REALImpl <em>SXCM REAL</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.SXCM_REALImpl
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getSXCM_REAL()
+	 * @generated
+	 */
+	int SXCM_REAL = 45;
+
+	/**
+	 * The feature id for the '<em><b>Null Flavor</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int SXCM_REAL__NULL_FLAVOR = REAL__NULL_FLAVOR;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int SXCM_REAL__VALUE = REAL__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Operator</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int SXCM_REAL__OPERATOR = REAL_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>SXCM REAL</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int SXCM_REAL_FEATURE_COUNT = REAL_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVXB_REALImpl <em>IVXB REAL</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.IVXB_REALImpl
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getIVXB_REAL()
+	 * @generated
+	 */
+	int IVXB_REAL = 46;
+
+	/**
+	 * The feature id for the '<em><b>Null Flavor</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVXB_REAL__NULL_FLAVOR = REAL__NULL_FLAVOR;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVXB_REAL__VALUE = REAL__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Inclusive</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVXB_REAL__INCLUSIVE = REAL_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>IVXB REAL</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVXB_REAL_FEATURE_COUNT = REAL_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl <em>IVL REAL</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getIVL_REAL()
+	 * @generated
+	 */
+	int IVL_REAL = 47;
+
+	/**
+	 * The feature id for the '<em><b>Null Flavor</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__NULL_FLAVOR = SXCM_REAL__NULL_FLAVOR;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__VALUE = SXCM_REAL__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Operator</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__OPERATOR = SXCM_REAL__OPERATOR;
+
+	/**
+	 * The feature id for the '<em><b>Low</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__LOW = SXCM_REAL_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Center</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__CENTER = SXCM_REAL_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>High</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__HIGH = SXCM_REAL_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Width</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL__WIDTH = SXCM_REAL_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>IVL REAL</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int IVL_REAL_FEATURE_COUNT = SXCM_REAL_FEATURE_COUNT + 4;
+
+	/**
 	 * The meta object id for the '{@link org.eclipse.mdht.uml.hl7.datatypes.BinaryDataEncoding <em>Binary Data Encoding</em>}' enum.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -3736,7 +3910,7 @@
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getBinaryDataEncoding()
 	 * @generated
 	 */
-	int BINARY_DATA_ENCODING = 45;
+	int BINARY_DATA_ENCODING = 48;
 
 	/**
 	 * The meta object id for the '<em>cs Type</em>' data type.
@@ -3746,7 +3920,7 @@
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getcsType()
 	 * @generated
 	 */
-	int CS_TYPE = 47;
+	int CS_TYPE = 50;
 
 	/**
 	 * The meta object id for the '<em>uid</em>' data type.
@@ -3756,7 +3930,7 @@
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getuid()
 	 * @generated
 	 */
-	int UID = 48;
+	int UID = 51;
 
 	/**
 	 * The meta object id for the '<em>st Type</em>' data type.
@@ -3766,7 +3940,7 @@
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getstType()
 	 * @generated
 	 */
-	int ST_TYPE = 49;
+	int ST_TYPE = 52;
 
 	/**
 	 * The meta object id for the '<em>ts Type</em>' data type.
@@ -3776,7 +3950,7 @@
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#gettsType()
 	 * @generated
 	 */
-	int TS_TYPE = 46;
+	int TS_TYPE = 49;
 
 	/**
 	 * Returns the meta object for class '{@link org.eclipse.mdht.uml.hl7.datatypes.ANY <em>ANY</em>}'.
@@ -5527,6 +5701,102 @@
 	EReference getEIVL_TS_Offset();
 
 	/**
+	 * Returns the meta object for class '{@link org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL <em>SXCM REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>SXCM REAL</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL
+	 * @generated
+	 */
+	EClass getSXCM_REAL();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL#getOperator <em>Operator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Operator</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL#getOperator()
+	 * @see #getSXCM_REAL()
+	 * @generated
+	 */
+	EAttribute getSXCM_REAL_Operator();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL <em>IVXB REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>IVXB REAL</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL
+	 * @generated
+	 */
+	EClass getIVXB_REAL();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL#getInclusive <em>Inclusive</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Inclusive</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL#getInclusive()
+	 * @see #getIVXB_REAL()
+	 * @generated
+	 */
+	EAttribute getIVXB_REAL_Inclusive();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL <em>IVL REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>IVL REAL</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL
+	 * @generated
+	 */
+	EClass getIVL_REAL();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getLow <em>Low</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Low</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getLow()
+	 * @see #getIVL_REAL()
+	 * @generated
+	 */
+	EReference getIVL_REAL_Low();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getCenter <em>Center</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Center</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getCenter()
+	 * @see #getIVL_REAL()
+	 * @generated
+	 */
+	EReference getIVL_REAL_Center();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getHigh <em>High</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>High</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getHigh()
+	 * @see #getIVL_REAL()
+	 * @generated
+	 */
+	EReference getIVL_REAL_High();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getWidth <em>Width</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Width</em>'.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getWidth()
+	 * @see #getIVL_REAL()
+	 * @generated
+	 */
+	EReference getIVL_REAL_Width();
+
+	/**
 	 * Returns the meta object for enum '{@link org.eclipse.mdht.uml.hl7.datatypes.BinaryDataEncoding <em>Binary Data Encoding</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -7001,6 +7271,84 @@
 		EReference EIVL_TS__OFFSET = eINSTANCE.getEIVL_TS_Offset();
 
 		/**
+		 * The meta object literal for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.SXCM_REALImpl <em>SXCM REAL</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.SXCM_REALImpl
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getSXCM_REAL()
+		 * @generated
+		 */
+		EClass SXCM_REAL = eINSTANCE.getSXCM_REAL();
+
+		/**
+		 * The meta object literal for the '<em><b>Operator</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute SXCM_REAL__OPERATOR = eINSTANCE.getSXCM_REAL_Operator();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVXB_REALImpl <em>IVXB REAL</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.IVXB_REALImpl
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getIVXB_REAL()
+		 * @generated
+		 */
+		EClass IVXB_REAL = eINSTANCE.getIVXB_REAL();
+
+		/**
+		 * The meta object literal for the '<em><b>Inclusive</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute IVXB_REAL__INCLUSIVE = eINSTANCE.getIVXB_REAL_Inclusive();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl <em>IVL REAL</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl
+		 * @see org.eclipse.mdht.uml.hl7.datatypes.impl.DatatypesPackageImpl#getIVL_REAL()
+		 * @generated
+		 */
+		EClass IVL_REAL = eINSTANCE.getIVL_REAL();
+
+		/**
+		 * The meta object literal for the '<em><b>Low</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference IVL_REAL__LOW = eINSTANCE.getIVL_REAL_Low();
+
+		/**
+		 * The meta object literal for the '<em><b>Center</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference IVL_REAL__CENTER = eINSTANCE.getIVL_REAL_Center();
+
+		/**
+		 * The meta object literal for the '<em><b>High</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference IVL_REAL__HIGH = eINSTANCE.getIVL_REAL_High();
+
+		/**
+		 * The meta object literal for the '<em><b>Width</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference IVL_REAL__WIDTH = eINSTANCE.getIVL_REAL_Width();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.mdht.uml.hl7.datatypes.BinaryDataEncoding <em>Binary Data Encoding</em>}' enum.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_INT.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_INT.java
index 994b588..7e0dc39 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_INT.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_INT.java
@@ -30,7 +30,7 @@
  * </ul>
  *
  * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_INT()
- * @model
+ * @model annotation="duplicates"
  * @generated
  */
 public interface IVL_INT extends SXCM_INT {
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_REAL.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_REAL.java
new file mode 100644
index 0000000..c2d318a
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVL_REAL.java
@@ -0,0 +1,165 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes;
+
+import java.util.Map;
+
+import org.eclipse.emf.common.util.DiagnosticChain;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>IVL REAL</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getLow <em>Low</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getCenter <em>Center</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getHigh <em>High</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getWidth <em>Width</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_REAL()
+ * @model
+ * @generated
+ */
+public interface IVL_REAL extends SXCM_REAL {
+	/**
+	 * Returns the value of the '<em><b>Low</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Low</em>' containment reference.
+	 * @see #setLow(IVL_REAL)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_REAL_Low()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	IVL_REAL getLow();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getLow <em>Low</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Low</em>' containment reference.
+	 * @see #getLow()
+	 * @generated
+	 */
+	void setLow(IVL_REAL value);
+
+	/**
+	 * Returns the value of the '<em><b>Center</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Center</em>' containment reference.
+	 * @see #setCenter(REAL)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_REAL_Center()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	REAL getCenter();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getCenter <em>Center</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Center</em>' containment reference.
+	 * @see #getCenter()
+	 * @generated
+	 */
+	void setCenter(REAL value);
+
+	/**
+	 * Returns the value of the '<em><b>High</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>High</em>' containment reference.
+	 * @see #setHigh(IVL_REAL)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_REAL_High()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	IVL_REAL getHigh();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getHigh <em>High</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>High</em>' containment reference.
+	 * @see #getHigh()
+	 * @generated
+	 */
+	void setHigh(IVL_REAL value);
+
+	/**
+	 * Returns the value of the '<em><b>Width</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Width</em>' containment reference.
+	 * @see #setWidth(REAL)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVL_REAL_Width()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	REAL getWidth();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#getWidth <em>Width</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Width</em>' containment reference.
+	 * @see #getWidth()
+	 * @generated
+	 */
+	void setWidth(REAL value);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @model annotation="http://www.eclipse.org/uml2/1.1.0/GenModel body='not self.low.oclIsUndefined() implies self.center.oclIsUndefined() and (self.width.oclIsUndefined() or self.high.oclIsUndefined())'"
+	 * @generated
+	 */
+	boolean validateOptionsContainingLow(DiagnosticChain diagnostics, Map<Object, Object> context);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @model annotation="http://www.eclipse.org/uml2/1.1.0/GenModel body='not self.center.oclIsUndefined() implies self.high.oclIsUndefined() and self.low.oclIsUndefined()'"
+	 * @generated
+	 */
+	boolean validateOptionsContainingCenter(DiagnosticChain diagnostics, Map<Object, Object> context);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @model annotation="http://www.eclipse.org/uml2/1.1.0/GenModel body='not self.high.oclIsUndefined() implies (self.low.oclIsUndefined() and self.center.oclIsUndefined() and self.width.oclIsUndefined()) or ((not self.low.oclIsUndefined()) and self.width.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.width.oclIsUndefined()) and self.low.oclIsUndefined() and self.center.oclIsUndefined())'"
+	 * @generated
+	 */
+	boolean validateOptionsContainingHigh(DiagnosticChain diagnostics, Map<Object, Object> context);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @model annotation="http://www.eclipse.org/uml2/1.1.0/GenModel body='not self.width.oclIsUndefined() implies ((not self.low.oclIsUndefined()) and self.center.oclIsUndefined() and self.high.oclIsUndefined()) or (self.low.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.center.oclIsUndefined()) and self.low.oclIsUndefined() and self.high.oclIsUndefined())'"
+	 * @generated
+	 */
+	boolean validateOptionsContainingWidth(DiagnosticChain diagnostics, Map<Object, Object> context);
+
+} // IVL_REAL
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVXB_REAL.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVXB_REAL.java
new file mode 100644
index 0000000..e20c282
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/IVXB_REAL.java
@@ -0,0 +1,45 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>IVXB REAL</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL#getInclusive <em>Inclusive</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVXB_REAL()
+ * @model
+ * @generated
+ */
+public interface IVXB_REAL extends REAL {
+	/**
+	 * Returns the value of the '<em><b>Inclusive</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Inclusive</em>' attribute.
+	 * @see #setInclusive(Boolean)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getIVXB_REAL_Inclusive()
+	 * @model default="true" ordered="false"
+	 * @generated
+	 */
+	Boolean getInclusive();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL#getInclusive <em>Inclusive</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Inclusive</em>' attribute.
+	 * @see #getInclusive()
+	 * @generated
+	 */
+	void setInclusive(Boolean value);
+
+} // IVXB_REAL
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/SXCM_REAL.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/SXCM_REAL.java
new file mode 100644
index 0000000..d1b0dab
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/SXCM_REAL.java
@@ -0,0 +1,50 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes;
+
+import org.eclipse.mdht.uml.hl7.vocab.SetOperator;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>SXCM REAL</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL#getOperator <em>Operator</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getSXCM_REAL()
+ * @model
+ * @generated
+ */
+public interface SXCM_REAL extends REAL {
+	/**
+	 * Returns the value of the '<em><b>Operator</b></em>' attribute.
+	 * The default value is <code>"I"</code>.
+	 * The literals are from the enumeration {@link org.eclipse.mdht.uml.hl7.vocab.SetOperator}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Operator</em>' attribute.
+	 * @see org.eclipse.mdht.uml.hl7.vocab.SetOperator
+	 * @see #setOperator(SetOperator)
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getSXCM_REAL_Operator()
+	 * @model default="I" ordered="false"
+	 * @generated
+	 */
+	SetOperator getOperator();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL#getOperator <em>Operator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Operator</em>' attribute.
+	 * @see org.eclipse.mdht.uml.hl7.vocab.SetOperator
+	 * @see #getOperator()
+	 * @generated
+	 */
+	void setOperator(SetOperator value);
+
+} // SXCM_REAL
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/TEL.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/TEL.java
index 35c3545..df4749c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/TEL.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/TEL.java
@@ -104,7 +104,7 @@
 	 * @return the value of the '<em>Mixed</em>' attribute list.
 	 * @see org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage#getTEL_Mixed()
 	 * @model unique="false" dataType="org.eclipse.emf.ecore.EFeatureMapEntry" many="true"
-	 *        extendedMetaData="name='mixed' kind='elementWildcard'"
+	 *        extendedMetaData="name='mixed' namespace='' kind='elementWildcard'"
 	 * @generated
 	 */
 	FeatureMap getMixed();
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADImpl.java
index da2f05b..eff903b 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADImpl.java
@@ -140,6 +140,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<SXCM_TS> getUseablePeriods() {
 		return getMixed().list(DatatypesPackage.Literals.AD__USEABLE_PERIOD);
 	}
@@ -149,6 +150,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<PostalAddressUse> getUses() {
 		if (uses == null) {
 			uses = new EDataTypeUniqueEList.Unsettable<PostalAddressUse>(
@@ -162,6 +164,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetUses() {
 		if (uses != null) {
 			((InternalEList.Unsettable<?>) uses).unset();
@@ -173,6 +176,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetUses() {
 		return uses != null && ((InternalEList.Unsettable<?>) uses).isSet();
 	}
@@ -182,6 +186,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getIsNotOrdered() {
 		return isNotOrdered;
 	}
@@ -191,6 +196,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setIsNotOrdered(Boolean newIsNotOrdered) {
 		Boolean oldIsNotOrdered = isNotOrdered;
 		isNotOrdered = newIsNotOrdered;
@@ -206,6 +212,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDelimiters() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIMITER);
 	}
@@ -215,6 +222,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getCountries() {
 		return getParts().list(DatatypesPackage.Literals.AD__COUNTRY);
 	}
@@ -224,6 +232,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getStates() {
 		return getParts().list(DatatypesPackage.Literals.AD__STATE);
 	}
@@ -233,6 +242,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getCounties() {
 		return getParts().list(DatatypesPackage.Literals.AD__COUNTY);
 	}
@@ -242,6 +252,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getCities() {
 		return getParts().list(DatatypesPackage.Literals.AD__CITY);
 	}
@@ -251,6 +262,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getPostalCodes() {
 		return getParts().list(DatatypesPackage.Literals.AD__POSTAL_CODE);
 	}
@@ -260,6 +272,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getStreetAddressLines() {
 		return getParts().list(DatatypesPackage.Literals.AD__STREET_ADDRESS_LINE);
 	}
@@ -269,6 +282,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getHouseNumbers() {
 		return getParts().list(DatatypesPackage.Literals.AD__HOUSE_NUMBER);
 	}
@@ -278,6 +292,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getHouseNumberNumerics() {
 		return getParts().list(DatatypesPackage.Literals.AD__HOUSE_NUMBER_NUMERIC);
 	}
@@ -287,6 +302,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDirections() {
 		return getParts().list(DatatypesPackage.Literals.AD__DIRECTION);
 	}
@@ -296,6 +312,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getStreetNames() {
 		return getParts().list(DatatypesPackage.Literals.AD__STREET_NAME);
 	}
@@ -305,6 +322,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getStreetNameBases() {
 		return getParts().list(DatatypesPackage.Literals.AD__STREET_NAME_BASE);
 	}
@@ -314,6 +332,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getStreetNameTypes() {
 		return getParts().list(DatatypesPackage.Literals.AD__STREET_NAME_TYPE);
 	}
@@ -323,6 +342,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getAdditionalLocators() {
 		return getParts().list(DatatypesPackage.Literals.AD__ADDITIONAL_LOCATOR);
 	}
@@ -332,6 +352,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getUnitIDs() {
 		return getParts().list(DatatypesPackage.Literals.AD__UNIT_ID);
 	}
@@ -341,6 +362,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getUnitTypes() {
 		return getParts().list(DatatypesPackage.Literals.AD__UNIT_TYPE);
 	}
@@ -350,6 +372,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getCareOfs() {
 		return getParts().list(DatatypesPackage.Literals.AD__CARE_OF);
 	}
@@ -359,6 +382,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getCensusTracts() {
 		return getParts().list(DatatypesPackage.Literals.AD__CENSUS_TRACT);
 	}
@@ -368,6 +392,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryAddressLines() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_ADDRESS_LINE);
 	}
@@ -377,6 +402,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryInstallationTypes() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_INSTALLATION_TYPE);
 	}
@@ -386,6 +412,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryInstallationAreas() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_INSTALLATION_AREA);
 	}
@@ -395,6 +422,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryInstallationQualifiers() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_INSTALLATION_QUALIFIER);
 	}
@@ -404,6 +432,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryModes() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_MODE);
 	}
@@ -413,6 +442,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getDeliveryModeIdentifiers() {
 		return getParts().list(DatatypesPackage.Literals.AD__DELIVERY_MODE_IDENTIFIER);
 	}
@@ -422,6 +452,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getBuildingNumberSuffixes() {
 		return getParts().list(DatatypesPackage.Literals.AD__BUILDING_NUMBER_SUFFIX);
 	}
@@ -431,6 +462,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getPostBoxes() {
 		return getParts().list(DatatypesPackage.Literals.AD__POST_BOX);
 	}
@@ -440,6 +472,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ADXP> getPrecincts() {
 		return getParts().list(DatatypesPackage.Literals.AD__PRECINCT);
 	}
@@ -449,6 +482,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getParts() {
 		return (FeatureMap) getMixed().<FeatureMap.Entry> list(DatatypesPackage.Literals.AD__PART);
 	}
@@ -458,6 +492,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getMixed() {
 		if (mixed == null) {
 			mixed = new BasicFeatureMap(this, DatatypesPackage.AD__MIXED);
@@ -1400,7 +1435,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (use: ");
 		result.append(uses);
 		result.append(", isNotOrdered: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADXPImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADXPImpl.java
index ab76e59..8f8214e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADXPImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ADXPImpl.java
@@ -84,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public AddressPartType getPartType() {
 		return partType;
 	}
@@ -93,6 +94,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setPartType(AddressPartType newPartType) {
 		AddressPartType oldPartType = partType;
 		partType = newPartType == null
@@ -112,6 +114,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetPartType() {
 		AddressPartType oldPartType = partType;
 		boolean oldPartTypeESet = partTypeESet;
@@ -130,6 +133,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetPartType() {
 		return partTypeESet;
 	}
@@ -203,7 +207,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (partType: ");
 		if (partTypeESet) {
 			result.append(partType);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ANYImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ANYImpl.java
index af0886b..2d06b17 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ANYImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ANYImpl.java
@@ -86,6 +86,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public NullFlavor getNullFlavor() {
 		return nullFlavor;
 	}
@@ -95,6 +96,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setNullFlavor(NullFlavor newNullFlavor) {
 		NullFlavor oldNullFlavor = nullFlavor;
 		nullFlavor = newNullFlavor == null
@@ -115,6 +117,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetNullFlavor() {
 		NullFlavor oldNullFlavor = nullFlavor;
 		boolean oldNullFlavorESet = nullFlavorESet;
@@ -133,6 +136,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetNullFlavor() {
 		return nullFlavorESet;
 	}
@@ -251,7 +255,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (nullFlavor: ");
 		if (nullFlavorESet) {
 			result.append(nullFlavor);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BINImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BINImpl.java
index 21c8b5a..d4f0b54 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BINImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BINImpl.java
@@ -84,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BinaryDataEncoding getRepresentation() {
 		return representation;
 	}
@@ -93,6 +94,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setRepresentation(BinaryDataEncoding newRepresentation) {
 		BinaryDataEncoding oldRepresentation = representation;
 		representation = newRepresentation == null
@@ -113,6 +115,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetRepresentation() {
 		BinaryDataEncoding oldRepresentation = representation;
 		boolean oldRepresentationESet = representationESet;
@@ -131,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetRepresentation() {
 		return representationESet;
 	}
@@ -204,7 +208,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (representation: ");
 		if (representationESet) {
 			result.append(representation);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BLImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BLImpl.java
index a67ad7c..cf819ad 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BLImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/BLImpl.java
@@ -78,6 +78,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getValue() {
 		return value;
 	}
@@ -87,6 +88,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(Boolean newValue) {
 		Boolean oldValue = value;
 		value = newValue;
@@ -175,7 +177,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CDImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CDImpl.java
index e0b596b..0aefb5c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CDImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CDImpl.java
@@ -242,6 +242,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ED getOriginalText() {
 		return originalText;
 	}
@@ -271,6 +272,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setOriginalText(ED newOriginalText) {
 		if (newOriginalText != originalText) {
 			NotificationChain msgs = null;
@@ -298,6 +300,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<CR> getQualifiers() {
 		if (qualifiers == null) {
 			qualifiers = new EObjectContainmentEList<CR>(CR.class, this, DatatypesPackage.CD__QUALIFIER);
@@ -310,6 +313,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<CD> getTranslations() {
 		if (translations == null) {
 			translations = new EObjectContainmentEList<CD>(CD.class, this, DatatypesPackage.CD__TRANSLATION);
@@ -322,6 +326,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCode() {
 		return code;
 	}
@@ -331,6 +336,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCode(String newCode) {
 		String oldCode = code;
 		code = newCode;
@@ -344,6 +350,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystem() {
 		return codeSystem;
 	}
@@ -353,6 +360,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystem(String newCodeSystem) {
 		String oldCodeSystem = codeSystem;
 		codeSystem = newCodeSystem;
@@ -368,6 +376,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystemName() {
 		return codeSystemName;
 	}
@@ -377,6 +386,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystemName(String newCodeSystemName) {
 		String oldCodeSystemName = codeSystemName;
 		codeSystemName = newCodeSystemName;
@@ -392,6 +402,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystemVersion() {
 		return codeSystemVersion;
 	}
@@ -401,6 +412,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystemVersion(String newCodeSystemVersion) {
 		String oldCodeSystemVersion = codeSystemVersion;
 		codeSystemVersion = newCodeSystemVersion;
@@ -417,6 +429,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getDisplayName() {
 		return displayName;
 	}
@@ -426,6 +439,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setDisplayName(String newDisplayName) {
 		String oldDisplayName = displayName;
 		displayName = newDisplayName;
@@ -441,6 +455,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getSDTCValueSet() {
 		return sDTCValueSet;
 	}
@@ -450,6 +465,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setSDTCValueSet(String newSDTCValueSet) {
 		String oldSDTCValueSet = sDTCValueSet;
 		sDTCValueSet = newSDTCValueSet;
@@ -465,6 +481,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getSDTCValueSetVersion() {
 		return sDTCValueSetVersion;
 	}
@@ -474,6 +491,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setSDTCValueSetVersion(String newSDTCValueSetVersion) {
 		String oldSDTCValueSetVersion = sDTCValueSetVersion;
 		sDTCValueSetVersion = newSDTCValueSetVersion;
@@ -679,7 +697,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (code: ");
 		result.append(code);
 		result.append(", codeSystem: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CRImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CRImpl.java
index 2fafa82..405bb61 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CRImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/CRImpl.java
@@ -104,6 +104,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CV getName() {
 		return name;
 	}
@@ -133,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setName(CV newName) {
 		if (newName != name) {
 			NotificationChain msgs = null;
@@ -158,6 +160,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CD getValue() {
 		return value;
 	}
@@ -187,6 +190,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(CD newValue) {
 		if (newValue != value) {
 			NotificationChain msgs = null;
@@ -212,6 +216,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isInverted() {
 		return inverted;
 	}
@@ -221,6 +226,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setInverted(boolean newInverted) {
 		boolean oldInverted = inverted;
 		inverted = newInverted;
@@ -344,7 +350,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (inverted: ");
 		result.append(inverted);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesFactoryImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesFactoryImpl.java
index a0cd94c..4c73e2c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesFactoryImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesFactoryImpl.java
@@ -19,6 +19,7 @@
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
 import org.eclipse.emf.ecore.xml.type.XMLTypeFactory;
 import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
+import org.eclipse.mdht.uml.hl7.datatypes.*;
 import org.eclipse.mdht.uml.hl7.datatypes.AD;
 import org.eclipse.mdht.uml.hl7.datatypes.ADXP;
 import org.eclipse.mdht.uml.hl7.datatypes.BL;
@@ -193,6 +194,12 @@
 				return createEIVL_event();
 			case DatatypesPackage.EIVL_TS:
 				return createEIVL_TS();
+			case DatatypesPackage.SXCM_REAL:
+				return createSXCM_REAL();
+			case DatatypesPackage.IVXB_REAL:
+				return createIVXB_REAL();
+			case DatatypesPackage.IVL_REAL:
+				return createIVL_REAL();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
@@ -251,6 +258,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ED createED() {
 		EDImpl ed = new EDImpl();
 		return ed;
@@ -267,6 +275,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public TEL createTEL() {
 		TELImpl tel = new TELImpl();
 		return tel;
@@ -283,6 +292,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SXCM_TS createSXCM_TS() {
 		SXCM_TSImpl sxcM_TS = new SXCM_TSImpl();
 		return sxcM_TS;
@@ -293,6 +303,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public TS createTS() {
 		TSImpl ts = new TSImpl();
 		return ts;
@@ -309,6 +320,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ST createST() {
 		STImpl st = new STImpl();
 		return st;
@@ -325,6 +337,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CD createCD() {
 		CDImpl cd = new CDImpl();
 		return cd;
@@ -349,6 +362,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CR createCR() {
 		CRImpl cr = new CRImpl();
 		return cr;
@@ -359,6 +373,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CV createCV() {
 		CVImpl cv = new CVImpl();
 		return cv;
@@ -369,6 +384,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CE createCE() {
 		CEImpl ce = new CEImpl();
 		return ce;
@@ -393,6 +409,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public II createII() {
 		IIImpl ii = new IIImpl();
 		return ii;
@@ -421,6 +438,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BL createBL() {
 		BLImpl bl = new BLImpl();
 		return bl;
@@ -437,6 +455,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BN createBN() {
 		BNImpl bn = new BNImpl();
 		return bn;
@@ -453,6 +472,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public AD createAD() {
 		ADImpl ad = new ADImpl();
 		return ad;
@@ -463,6 +483,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ADXP createADXP() {
 		ADXPImpl adxp = new ADXPImpl();
 		return adxp;
@@ -480,6 +501,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EN createEN() {
 		ENImpl en = new ENImpl();
 		return en;
@@ -490,6 +512,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_TS createIVL_TS() {
 		IVL_TSImpl ivL_TS = new IVL_TSImpl();
 		return ivL_TS;
@@ -521,6 +544,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_TS createIVXB_TS() {
 		IVXB_TSImpl ivxB_TS = new IVXB_TSImpl();
 		return ivxB_TS;
@@ -531,6 +555,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ createPQ() {
 		PQImpl pq = new PQImpl();
 		return pq;
@@ -548,6 +573,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQR createPQR() {
 		PQRImpl pqr = new PQRImpl();
 		return pqr;
@@ -558,6 +584,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ENXP createENXP() {
 		ENXPImpl enxp = new ENXPImpl();
 		return enxp;
@@ -575,6 +602,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ON createON() {
 		ONImpl on = new ONImpl();
 		return on;
@@ -585,6 +613,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PN createPN() {
 		PNImpl pn = new PNImpl();
 		return pn;
@@ -595,6 +624,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public TN createTN() {
 		TNImpl tn = new TNImpl();
 		return tn;
@@ -605,6 +635,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public INT createINT() {
 		INTImpl int_ = new INTImpl();
 		return int_;
@@ -615,6 +646,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public REAL createREAL() {
 		REALImpl real = new REALImpl();
 		return real;
@@ -625,6 +657,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CS createCS() {
 		CSImpl cs = new CSImpl();
 		return cs;
@@ -641,6 +674,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CO createCO() {
 		COImpl co = new COImpl();
 		return co;
@@ -651,6 +685,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SC createSC() {
 		SCImpl sc = new SCImpl();
 		return sc;
@@ -661,6 +696,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public RTO_QTY_QTY createRTO_QTY_QTY() {
 		RTO_QTY_QTYImpl rtO_QTY_QTY = new RTO_QTY_QTYImpl();
 		return rtO_QTY_QTY;
@@ -671,6 +707,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public MO createMO() {
 		MOImpl mo = new MOImpl();
 		return mo;
@@ -681,6 +718,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public RTO createRTO() {
 		RTOImpl rto = new RTOImpl();
 		return rto;
@@ -691,6 +729,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SXCM_INT createSXCM_INT() {
 		SXCM_INTImpl sxcM_INT = new SXCM_INTImpl();
 		return sxcM_INT;
@@ -701,6 +740,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_INT createIVXB_INT() {
 		IVXB_INTImpl ivxB_INT = new IVXB_INTImpl();
 		return ivxB_INT;
@@ -711,6 +751,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_INT createIVL_INT() {
 		IVL_INTImpl ivL_INT = new IVL_INTImpl();
 		return ivL_INT;
@@ -721,6 +762,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_PQ createIVXB_PQ() {
 		IVXB_PQImpl ivxB_PQ = new IVXB_PQImpl();
 		return ivxB_PQ;
@@ -731,6 +773,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SXCM_PQ createSXCM_PQ() {
 		SXCM_PQImpl sxcM_PQ = new SXCM_PQImpl();
 		return sxcM_PQ;
@@ -741,6 +784,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_PQ createIVL_PQ() {
 		IVL_PQImpl ivL_PQ = new IVL_PQImpl();
 		return ivL_PQ;
@@ -751,6 +795,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public RTO_PQ_PQ createRTO_PQ_PQ() {
 		RTO_PQ_PQImpl rtO_PQ_PQ = new RTO_PQ_PQImpl();
 		return rtO_PQ_PQ;
@@ -761,6 +806,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PIVL_TS createPIVL_TS() {
 		PIVL_TSImpl pivL_TS = new PIVL_TSImpl();
 		return pivL_TS;
@@ -771,6 +817,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EIVL_event createEIVL_event() {
 		EIVL_eventImpl eivL_event = new EIVL_eventImpl();
 		return eivL_event;
@@ -781,6 +828,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EIVL_TS createEIVL_TS() {
 		EIVL_TSImpl eivL_TS = new EIVL_TSImpl();
 		return eivL_TS;
@@ -791,6 +839,39 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
+	public SXCM_REAL createSXCM_REAL() {
+		SXCM_REALImpl sxcM_REAL = new SXCM_REALImpl();
+		return sxcM_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public IVXB_REAL createIVXB_REAL() {
+		IVXB_REALImpl ivxB_REAL = new IVXB_REALImpl();
+		return ivxB_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public IVL_REAL createIVL_REAL() {
+		IVL_REALImpl ivL_REAL = new IVL_REALImpl();
+		return ivL_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public BinaryDataEncoding createBinaryDataEncodingFromString(EDataType eDataType, String initialValue) {
 		BinaryDataEncoding result = BinaryDataEncoding.get(initialValue);
 		if (result == null) {
@@ -888,6 +969,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public DatatypesPackage getDatatypesPackage() {
 		return (DatatypesPackage) getEPackage();
 	}
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesPackageImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesPackageImpl.java
index 28cbacc..ef0a24d 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesPackageImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/DatatypesPackageImpl.java
@@ -355,6 +355,27 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	private EClass sxcM_REALEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass ivxB_REALEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass ivL_REALEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	private EEnum binaryDataEncodingEEnum = null;
 
 	/**
@@ -429,10 +450,10 @@
 		}
 
 		// Obtain or create and register package
-		DatatypesPackageImpl theDatatypesPackage = (DatatypesPackageImpl) (EPackage.Registry.INSTANCE.get(
-			eNS_URI) instanceof DatatypesPackageImpl
-					? EPackage.Registry.INSTANCE.get(eNS_URI)
-					: new DatatypesPackageImpl());
+		Object registeredDatatypesPackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+		DatatypesPackageImpl theDatatypesPackage = registeredDatatypesPackage instanceof DatatypesPackageImpl
+				? (DatatypesPackageImpl) registeredDatatypesPackage
+				: new DatatypesPackageImpl();
 
 		isInited = true;
 
@@ -448,6 +469,7 @@
 
 		// Register package validator
 		EValidator.Registry.INSTANCE.put(theDatatypesPackage, new EValidator.Descriptor() {
+			@Override
 			public EValidator getEValidator() {
 				return DatatypesValidator.INSTANCE;
 			}
@@ -466,6 +488,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getANY() {
 		return anyEClass;
 	}
@@ -475,6 +498,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getANY_NullFlavor() {
 		return (EAttribute) anyEClass.getEStructuralFeatures().get(0);
 	}
@@ -484,6 +508,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getBIN() {
 		return binEClass;
 	}
@@ -493,6 +518,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getBIN_Representation() {
 		return (EAttribute) binEClass.getEStructuralFeatures().get(0);
 	}
@@ -502,6 +528,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getED() {
 		return edEClass;
 	}
@@ -511,6 +538,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_Mixed() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(0);
 	}
@@ -520,6 +548,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getED_Reference() {
 		return (EReference) edEClass.getEStructuralFeatures().get(1);
 	}
@@ -529,6 +558,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getED_Thumbnail() {
 		return (EReference) edEClass.getEStructuralFeatures().get(2);
 	}
@@ -538,6 +568,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_MediaType() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(3);
 	}
@@ -547,6 +578,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_Language() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(4);
 	}
@@ -556,6 +588,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_Compression() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(5);
 	}
@@ -565,6 +598,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_IntegrityCheck() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(6);
 	}
@@ -574,6 +608,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getED_IntegrityCheckAlgorithm() {
 		return (EAttribute) edEClass.getEStructuralFeatures().get(7);
 	}
@@ -583,6 +618,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getTEL() {
 		return telEClass;
 	}
@@ -592,6 +628,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getTEL_UseablePeriod() {
 		return (EReference) telEClass.getEStructuralFeatures().get(0);
 	}
@@ -601,6 +638,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getTEL_Use() {
 		return (EAttribute) telEClass.getEStructuralFeatures().get(1);
 	}
@@ -610,6 +648,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getTEL_Mixed() {
 		return (EAttribute) telEClass.getEStructuralFeatures().get(2);
 	}
@@ -619,6 +658,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getURL() {
 		return urlEClass;
 	}
@@ -628,6 +668,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getURL_Value() {
 		return (EAttribute) urlEClass.getEStructuralFeatures().get(0);
 	}
@@ -637,6 +678,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getSXCM_TS() {
 		return sxcM_TSEClass;
 	}
@@ -646,6 +688,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSXCM_TS_Operator() {
 		return (EAttribute) sxcM_TSEClass.getEStructuralFeatures().get(0);
 	}
@@ -655,6 +698,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getTS() {
 		return tsEClass;
 	}
@@ -664,6 +708,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getTS_Value() {
 		return (EAttribute) tsEClass.getEStructuralFeatures().get(0);
 	}
@@ -673,6 +718,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getQTY() {
 		return qtyEClass;
 	}
@@ -682,6 +728,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getST() {
 		return stEClass;
 	}
@@ -691,6 +738,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCD() {
 		return cdEClass;
 	}
@@ -700,6 +748,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getCD_OriginalText() {
 		return (EReference) cdEClass.getEStructuralFeatures().get(0);
 	}
@@ -709,6 +758,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getCD_Qualifier() {
 		return (EReference) cdEClass.getEStructuralFeatures().get(1);
 	}
@@ -718,6 +768,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getCD_Translation() {
 		return (EReference) cdEClass.getEStructuralFeatures().get(2);
 	}
@@ -727,6 +778,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_Code() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(3);
 	}
@@ -736,6 +788,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_CodeSystem() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(4);
 	}
@@ -745,6 +798,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_CodeSystemName() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(5);
 	}
@@ -754,6 +808,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_CodeSystemVersion() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(6);
 	}
@@ -763,6 +818,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_DisplayName() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(7);
 	}
@@ -772,6 +828,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_SDTCValueSet() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(8);
 	}
@@ -781,6 +838,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCD_SDTCValueSetVersion() {
 		return (EAttribute) cdEClass.getEStructuralFeatures().get(9);
 	}
@@ -790,6 +848,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCR() {
 		return crEClass;
 	}
@@ -799,6 +858,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getCR_Name() {
 		return (EReference) crEClass.getEStructuralFeatures().get(0);
 	}
@@ -808,6 +868,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getCR_Value() {
 		return (EReference) crEClass.getEStructuralFeatures().get(1);
 	}
@@ -817,6 +878,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getCR_Inverted() {
 		return (EAttribute) crEClass.getEStructuralFeatures().get(2);
 	}
@@ -826,6 +888,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCV() {
 		return cvEClass;
 	}
@@ -835,6 +898,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCE() {
 		return ceEClass;
 	}
@@ -844,6 +908,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getII() {
 		return iiEClass;
 	}
@@ -853,6 +918,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getII_Root() {
 		return (EAttribute) iiEClass.getEStructuralFeatures().get(0);
 	}
@@ -862,6 +928,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getII_Extension() {
 		return (EAttribute) iiEClass.getEStructuralFeatures().get(1);
 	}
@@ -871,6 +938,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getII_AssigningAuthorityName() {
 		return (EAttribute) iiEClass.getEStructuralFeatures().get(2);
 	}
@@ -880,6 +948,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getII_Displayable() {
 		return (EAttribute) iiEClass.getEStructuralFeatures().get(3);
 	}
@@ -889,6 +958,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getBL() {
 		return blEClass;
 	}
@@ -898,6 +968,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getBL_Value() {
 		return (EAttribute) blEClass.getEStructuralFeatures().get(0);
 	}
@@ -907,6 +978,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getBN() {
 		return bnEClass;
 	}
@@ -916,6 +988,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getAD() {
 		return adEClass;
 	}
@@ -925,6 +998,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_UseablePeriod() {
 		return (EReference) adEClass.getEStructuralFeatures().get(28);
 	}
@@ -934,6 +1008,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getAD_Use() {
 		return (EAttribute) adEClass.getEStructuralFeatures().get(29);
 	}
@@ -943,6 +1018,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getAD_IsNotOrdered() {
 		return (EAttribute) adEClass.getEStructuralFeatures().get(30);
 	}
@@ -952,6 +1028,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_Delimiter() {
 		return (EReference) adEClass.getEStructuralFeatures().get(0);
 	}
@@ -961,6 +1038,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_Country() {
 		return (EReference) adEClass.getEStructuralFeatures().get(1);
 	}
@@ -970,6 +1048,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_State() {
 		return (EReference) adEClass.getEStructuralFeatures().get(2);
 	}
@@ -979,6 +1058,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_County() {
 		return (EReference) adEClass.getEStructuralFeatures().get(3);
 	}
@@ -988,6 +1068,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_City() {
 		return (EReference) adEClass.getEStructuralFeatures().get(4);
 	}
@@ -997,6 +1078,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_PostalCode() {
 		return (EReference) adEClass.getEStructuralFeatures().get(5);
 	}
@@ -1006,6 +1088,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_StreetAddressLine() {
 		return (EReference) adEClass.getEStructuralFeatures().get(6);
 	}
@@ -1015,6 +1098,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_HouseNumber() {
 		return (EReference) adEClass.getEStructuralFeatures().get(7);
 	}
@@ -1024,6 +1108,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_HouseNumberNumeric() {
 		return (EReference) adEClass.getEStructuralFeatures().get(8);
 	}
@@ -1033,6 +1118,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_Direction() {
 		return (EReference) adEClass.getEStructuralFeatures().get(9);
 	}
@@ -1042,6 +1128,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_StreetName() {
 		return (EReference) adEClass.getEStructuralFeatures().get(10);
 	}
@@ -1051,6 +1138,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_StreetNameBase() {
 		return (EReference) adEClass.getEStructuralFeatures().get(11);
 	}
@@ -1060,6 +1148,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_StreetNameType() {
 		return (EReference) adEClass.getEStructuralFeatures().get(12);
 	}
@@ -1069,6 +1158,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_AdditionalLocator() {
 		return (EReference) adEClass.getEStructuralFeatures().get(13);
 	}
@@ -1078,6 +1168,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_UnitID() {
 		return (EReference) adEClass.getEStructuralFeatures().get(14);
 	}
@@ -1087,6 +1178,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_UnitType() {
 		return (EReference) adEClass.getEStructuralFeatures().get(15);
 	}
@@ -1096,6 +1188,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_CareOf() {
 		return (EReference) adEClass.getEStructuralFeatures().get(16);
 	}
@@ -1105,6 +1198,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_CensusTract() {
 		return (EReference) adEClass.getEStructuralFeatures().get(17);
 	}
@@ -1114,6 +1208,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryAddressLine() {
 		return (EReference) adEClass.getEStructuralFeatures().get(18);
 	}
@@ -1123,6 +1218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryInstallationType() {
 		return (EReference) adEClass.getEStructuralFeatures().get(19);
 	}
@@ -1132,6 +1228,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryInstallationArea() {
 		return (EReference) adEClass.getEStructuralFeatures().get(20);
 	}
@@ -1141,6 +1238,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryInstallationQualifier() {
 		return (EReference) adEClass.getEStructuralFeatures().get(21);
 	}
@@ -1150,6 +1248,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryMode() {
 		return (EReference) adEClass.getEStructuralFeatures().get(22);
 	}
@@ -1159,6 +1258,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_DeliveryModeIdentifier() {
 		return (EReference) adEClass.getEStructuralFeatures().get(23);
 	}
@@ -1168,6 +1268,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_BuildingNumberSuffix() {
 		return (EReference) adEClass.getEStructuralFeatures().get(24);
 	}
@@ -1177,6 +1278,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_PostBox() {
 		return (EReference) adEClass.getEStructuralFeatures().get(25);
 	}
@@ -1186,6 +1288,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getAD_Precinct() {
 		return (EReference) adEClass.getEStructuralFeatures().get(26);
 	}
@@ -1195,6 +1298,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getAD_Part() {
 		return (EAttribute) adEClass.getEStructuralFeatures().get(27);
 	}
@@ -1204,6 +1308,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getAD_Mixed() {
 		return (EAttribute) adEClass.getEStructuralFeatures().get(31);
 	}
@@ -1213,6 +1318,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getADXP() {
 		return adxpEClass;
 	}
@@ -1222,6 +1328,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getADXP_PartType() {
 		return (EAttribute) adxpEClass.getEStructuralFeatures().get(0);
 	}
@@ -1231,6 +1338,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getEN() {
 		return enEClass;
 	}
@@ -1240,6 +1348,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getEN_Use() {
 		return (EAttribute) enEClass.getEStructuralFeatures().get(7);
 	}
@@ -1249,6 +1358,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_ValidTime() {
 		return (EReference) enEClass.getEStructuralFeatures().get(6);
 	}
@@ -1258,6 +1368,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_Delimiter() {
 		return (EReference) enEClass.getEStructuralFeatures().get(0);
 	}
@@ -1267,6 +1378,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_Family() {
 		return (EReference) enEClass.getEStructuralFeatures().get(1);
 	}
@@ -1276,6 +1388,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_Given() {
 		return (EReference) enEClass.getEStructuralFeatures().get(2);
 	}
@@ -1285,6 +1398,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_Prefix() {
 		return (EReference) enEClass.getEStructuralFeatures().get(3);
 	}
@@ -1294,6 +1408,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEN_Suffix() {
 		return (EReference) enEClass.getEStructuralFeatures().get(4);
 	}
@@ -1303,6 +1418,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getEN_Part() {
 		return (EAttribute) enEClass.getEStructuralFeatures().get(5);
 	}
@@ -1312,6 +1428,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getEN_Mixed() {
 		return (EAttribute) enEClass.getEStructuralFeatures().get(8);
 	}
@@ -1321,6 +1438,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVL_TS() {
 		return ivL_TSEClass;
 	}
@@ -1330,6 +1448,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_TS_Low() {
 		return (EReference) ivL_TSEClass.getEStructuralFeatures().get(0);
 	}
@@ -1339,6 +1458,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_TS_Center() {
 		return (EReference) ivL_TSEClass.getEStructuralFeatures().get(1);
 	}
@@ -1348,6 +1468,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_TS_High() {
 		return (EReference) ivL_TSEClass.getEStructuralFeatures().get(2);
 	}
@@ -1357,6 +1478,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_TS_Width() {
 		return (EReference) ivL_TSEClass.getEStructuralFeatures().get(3);
 	}
@@ -1366,6 +1488,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVXB_TS() {
 		return ivxB_TSEClass;
 	}
@@ -1375,6 +1498,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getIVXB_TS_Inclusive() {
 		return (EAttribute) ivxB_TSEClass.getEStructuralFeatures().get(0);
 	}
@@ -1384,6 +1508,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getPQ() {
 		return pqEClass;
 	}
@@ -1393,6 +1518,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getPQ_Value() {
 		return (EAttribute) pqEClass.getEStructuralFeatures().get(0);
 	}
@@ -1402,6 +1528,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getPQ_Unit() {
 		return (EAttribute) pqEClass.getEStructuralFeatures().get(1);
 	}
@@ -1411,6 +1538,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getPQ_Translation() {
 		return (EReference) pqEClass.getEStructuralFeatures().get(2);
 	}
@@ -1420,6 +1548,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getPQR() {
 		return pqrEClass;
 	}
@@ -1429,6 +1558,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getPQR_Value() {
 		return (EAttribute) pqrEClass.getEStructuralFeatures().get(0);
 	}
@@ -1438,6 +1568,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getENXP() {
 		return enxpEClass;
 	}
@@ -1447,6 +1578,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getENXP_PartType() {
 		return (EAttribute) enxpEClass.getEStructuralFeatures().get(0);
 	}
@@ -1456,6 +1588,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getENXP_Qualifier() {
 		return (EAttribute) enxpEClass.getEStructuralFeatures().get(1);
 	}
@@ -1465,6 +1598,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getON() {
 		return onEClass;
 	}
@@ -1474,6 +1608,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getPN() {
 		return pnEClass;
 	}
@@ -1483,6 +1618,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getTN() {
 		return tnEClass;
 	}
@@ -1492,6 +1628,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getINT() {
 		return intEClass;
 	}
@@ -1501,6 +1638,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getINT_Value() {
 		return (EAttribute) intEClass.getEStructuralFeatures().get(0);
 	}
@@ -1510,6 +1648,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getREAL() {
 		return realEClass;
 	}
@@ -1519,6 +1658,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getREAL_Value() {
 		return (EAttribute) realEClass.getEStructuralFeatures().get(0);
 	}
@@ -1528,6 +1668,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCS() {
 		return csEClass;
 	}
@@ -1537,6 +1678,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getCO() {
 		return coEClass;
 	}
@@ -1546,6 +1688,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getSC() {
 		return scEClass;
 	}
@@ -1555,6 +1698,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSC_Code() {
 		return (EAttribute) scEClass.getEStructuralFeatures().get(0);
 	}
@@ -1564,6 +1708,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSC_CodeSystem() {
 		return (EAttribute) scEClass.getEStructuralFeatures().get(1);
 	}
@@ -1573,6 +1718,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSC_CodeSystemName() {
 		return (EAttribute) scEClass.getEStructuralFeatures().get(2);
 	}
@@ -1582,6 +1728,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSC_CodeSystemVersion() {
 		return (EAttribute) scEClass.getEStructuralFeatures().get(3);
 	}
@@ -1591,6 +1738,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSC_DisplayName() {
 		return (EAttribute) scEClass.getEStructuralFeatures().get(4);
 	}
@@ -1600,6 +1748,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getRTO_QTY_QTY() {
 		return rtO_QTY_QTYEClass;
 	}
@@ -1609,6 +1758,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getRTO_QTY_QTY_Numerator() {
 		return (EReference) rtO_QTY_QTYEClass.getEStructuralFeatures().get(0);
 	}
@@ -1618,6 +1768,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getRTO_QTY_QTY_Denominator() {
 		return (EReference) rtO_QTY_QTYEClass.getEStructuralFeatures().get(1);
 	}
@@ -1627,6 +1778,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getMO() {
 		return moEClass;
 	}
@@ -1636,6 +1788,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getMO_Value() {
 		return (EAttribute) moEClass.getEStructuralFeatures().get(0);
 	}
@@ -1645,6 +1798,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getMO_Currency() {
 		return (EAttribute) moEClass.getEStructuralFeatures().get(1);
 	}
@@ -1654,6 +1808,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getRTO() {
 		return rtoEClass;
 	}
@@ -1663,6 +1818,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getSXCM_INT() {
 		return sxcM_INTEClass;
 	}
@@ -1672,6 +1828,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSXCM_INT_Operator() {
 		return (EAttribute) sxcM_INTEClass.getEStructuralFeatures().get(0);
 	}
@@ -1681,6 +1838,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVXB_INT() {
 		return ivxB_INTEClass;
 	}
@@ -1690,6 +1848,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getIVXB_INT_Inclusive() {
 		return (EAttribute) ivxB_INTEClass.getEStructuralFeatures().get(0);
 	}
@@ -1699,6 +1858,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVL_INT() {
 		return ivL_INTEClass;
 	}
@@ -1708,6 +1868,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_INT_Low() {
 		return (EReference) ivL_INTEClass.getEStructuralFeatures().get(0);
 	}
@@ -1717,6 +1878,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_INT_Center() {
 		return (EReference) ivL_INTEClass.getEStructuralFeatures().get(1);
 	}
@@ -1726,6 +1888,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_INT_High() {
 		return (EReference) ivL_INTEClass.getEStructuralFeatures().get(2);
 	}
@@ -1735,6 +1898,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_INT_Width() {
 		return (EReference) ivL_INTEClass.getEStructuralFeatures().get(3);
 	}
@@ -1744,6 +1908,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVXB_PQ() {
 		return ivxB_PQEClass;
 	}
@@ -1753,6 +1918,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getIVXB_PQ_Inclusive() {
 		return (EAttribute) ivxB_PQEClass.getEStructuralFeatures().get(0);
 	}
@@ -1762,6 +1928,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getSXCM_PQ() {
 		return sxcM_PQEClass;
 	}
@@ -1771,6 +1938,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getSXCM_PQ_Operator() {
 		return (EAttribute) sxcM_PQEClass.getEStructuralFeatures().get(0);
 	}
@@ -1780,6 +1948,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getIVL_PQ() {
 		return ivL_PQEClass;
 	}
@@ -1789,6 +1958,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_PQ_Low() {
 		return (EReference) ivL_PQEClass.getEStructuralFeatures().get(0);
 	}
@@ -1798,6 +1968,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_PQ_Center() {
 		return (EReference) ivL_PQEClass.getEStructuralFeatures().get(1);
 	}
@@ -1807,6 +1978,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_PQ_High() {
 		return (EReference) ivL_PQEClass.getEStructuralFeatures().get(2);
 	}
@@ -1816,6 +1988,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getIVL_PQ_Width() {
 		return (EReference) ivL_PQEClass.getEStructuralFeatures().get(3);
 	}
@@ -1825,6 +1998,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getRTO_PQ_PQ() {
 		return rtO_PQ_PQEClass;
 	}
@@ -1834,6 +2008,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getRTO_PQ_PQ_Numerator() {
 		return (EReference) rtO_PQ_PQEClass.getEStructuralFeatures().get(0);
 	}
@@ -1843,6 +2018,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getRTO_PQ_PQ_Denominator() {
 		return (EReference) rtO_PQ_PQEClass.getEStructuralFeatures().get(1);
 	}
@@ -1852,6 +2028,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getPIVL_TS() {
 		return pivL_TSEClass;
 	}
@@ -1861,6 +2038,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getPIVL_TS_Phase() {
 		return (EReference) pivL_TSEClass.getEStructuralFeatures().get(0);
 	}
@@ -1870,6 +2048,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getPIVL_TS_Period() {
 		return (EReference) pivL_TSEClass.getEStructuralFeatures().get(1);
 	}
@@ -1879,6 +2058,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getPIVL_TS_Alignment() {
 		return (EAttribute) pivL_TSEClass.getEStructuralFeatures().get(2);
 	}
@@ -1888,6 +2068,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EAttribute getPIVL_TS_InstitutionSpecified() {
 		return (EAttribute) pivL_TSEClass.getEStructuralFeatures().get(3);
 	}
@@ -1897,6 +2078,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getEIVL_event() {
 		return eivL_eventEClass;
 	}
@@ -1906,6 +2088,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getEIVL_TS() {
 		return eivL_TSEClass;
 	}
@@ -1915,6 +2098,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEIVL_TS_Event() {
 		return (EReference) eivL_TSEClass.getEStructuralFeatures().get(0);
 	}
@@ -1924,6 +2108,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EReference getEIVL_TS_Offset() {
 		return (EReference) eivL_TSEClass.getEStructuralFeatures().get(1);
 	}
@@ -1933,6 +2118,97 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
+	public EClass getSXCM_REAL() {
+		return sxcM_REALEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getSXCM_REAL_Operator() {
+		return (EAttribute) sxcM_REALEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getIVXB_REAL() {
+		return ivxB_REALEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getIVXB_REAL_Inclusive() {
+		return (EAttribute) ivxB_REALEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getIVL_REAL() {
+		return ivL_REALEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getIVL_REAL_Low() {
+		return (EReference) ivL_REALEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getIVL_REAL_Center() {
+		return (EReference) ivL_REALEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getIVL_REAL_High() {
+		return (EReference) ivL_REALEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getIVL_REAL_Width() {
+		return (EReference) ivL_REALEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
 	public EEnum getBinaryDataEncoding() {
 		return binaryDataEncodingEEnum;
 	}
@@ -1942,6 +2218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EDataType getcsType() {
 		return csTypeEDataType;
 	}
@@ -1951,6 +2228,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EDataType getuid() {
 		return uidEDataType;
 	}
@@ -1960,6 +2238,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EDataType getstType() {
 		return stTypeEDataType;
 	}
@@ -1969,6 +2248,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EDataType gettsType() {
 		return tsTypeEDataType;
 	}
@@ -1978,6 +2258,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public DatatypesFactory getDatatypesFactory() {
 		return (DatatypesFactory) getEFactoryInstance();
 	}
@@ -2211,6 +2492,18 @@
 		createEReference(eivL_TSEClass, EIVL_TS__EVENT);
 		createEReference(eivL_TSEClass, EIVL_TS__OFFSET);
 
+		sxcM_REALEClass = createEClass(SXCM_REAL);
+		createEAttribute(sxcM_REALEClass, SXCM_REAL__OPERATOR);
+
+		ivxB_REALEClass = createEClass(IVXB_REAL);
+		createEAttribute(ivxB_REALEClass, IVXB_REAL__INCLUSIVE);
+
+		ivL_REALEClass = createEClass(IVL_REAL);
+		createEReference(ivL_REALEClass, IVL_REAL__LOW);
+		createEReference(ivL_REALEClass, IVL_REAL__CENTER);
+		createEReference(ivL_REALEClass, IVL_REAL__HIGH);
+		createEReference(ivL_REALEClass, IVL_REAL__WIDTH);
+
 		// Create enums
 		binaryDataEncodingEEnum = createEEnum(BINARY_DATA_ENCODING);
 
@@ -2299,6 +2592,9 @@
 		pivL_TSEClass.getESuperTypes().add(this.getSXCM_TS());
 		eivL_eventEClass.getESuperTypes().add(this.getCE());
 		eivL_TSEClass.getESuperTypes().add(this.getSXCM_TS());
+		sxcM_REALEClass.getESuperTypes().add(this.getREAL());
+		ivxB_REALEClass.getESuperTypes().add(this.getREAL());
+		ivL_REALEClass.getESuperTypes().add(this.getSXCM_REAL());
 
 		// Initialize classes and features; add operations and parameters
 		initEClass(
@@ -2393,17 +2689,15 @@
 			telEClass, org.eclipse.mdht.uml.hl7.datatypes.TEL.class, "TEL", !IS_ABSTRACT, !IS_INTERFACE,
 			IS_GENERATED_INSTANCE_CLASS);
 		initEReference(
-			getTEL_UseablePeriod(), this.getSXCM_TS(), null, "useablePeriod", null, 0, -1,
-			org.eclipse.mdht.uml.hl7.datatypes.TEL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
-			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+			getTEL_UseablePeriod(), this.getSXCM_TS(), null, "useablePeriod", null, 0, -1, null, !IS_TRANSIENT,
+			!IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
+			!IS_ORDERED);
 		initEAttribute(
-			getTEL_Use(), theVocabPackage.getTelecommunicationAddressUse(), "use", null, 0, -1,
-			org.eclipse.mdht.uml.hl7.datatypes.TEL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE,
-			!IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+			getTEL_Use(), theVocabPackage.getTelecommunicationAddressUse(), "use", null, 0, -1, null, !IS_TRANSIENT,
+			!IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 		initEAttribute(
-			getTEL_Mixed(), ecorePackage.getEFeatureMapEntry(), "mixed", null, 0, -1,
-			org.eclipse.mdht.uml.hl7.datatypes.TEL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE,
-			!IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+			getTEL_Mixed(), ecorePackage.getEFeatureMapEntry(), "mixed", null, 0, -1, null, !IS_TRANSIENT, !IS_VOLATILE,
+			IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		addEOperation(telEClass, theTypesPackage.getString(), "getText", 1, 1, IS_UNIQUE, !IS_ORDERED);
 
@@ -3827,6 +4121,82 @@
 			org.eclipse.mdht.uml.hl7.datatypes.EIVL_TS.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
 			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
+		initEClass(
+			sxcM_REALEClass, org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL.class, "SXCM_REAL", !IS_ABSTRACT,
+			!IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(
+			getSXCM_REAL_Operator(), theVocabPackage.getSetOperator(), "operator", "I", 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
+			!IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+
+		initEClass(
+			ivxB_REALEClass, org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL.class, "IVXB_REAL", !IS_ABSTRACT,
+			!IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(
+			getIVXB_REAL_Inclusive(), ecorePackage.getEBooleanObject(), "inclusive", "true", 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
+			!IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+
+		initEClass(
+			ivL_REALEClass, org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL.class, "IVL_REAL", !IS_ABSTRACT, !IS_INTERFACE,
+			IS_GENERATED_INSTANCE_CLASS);
+		initEReference(
+			getIVL_REAL_Low(), this.getIVL_REAL(), null, "low", null, 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
+			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(
+			getIVL_REAL_Center(), this.getREAL(), null, "center", null, 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
+			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(
+			getIVL_REAL_High(), this.getIVL_REAL(), null, "high", null, 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
+			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(
+			getIVL_REAL_Width(), this.getREAL(), null, "width", null, 0, 1,
+			org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE,
+			!IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+
+		op = addEOperation(
+			ivL_REALEClass, ecorePackage.getEBoolean(), "validateOptionsContainingLow", 0, 1, IS_UNIQUE, IS_ORDERED);
+		addEParameter(op, ecorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, IS_UNIQUE, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEMap());
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		op = addEOperation(
+			ivL_REALEClass, ecorePackage.getEBoolean(), "validateOptionsContainingCenter", 0, 1, IS_UNIQUE, IS_ORDERED);
+		addEParameter(op, ecorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, IS_UNIQUE, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEMap());
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		op = addEOperation(
+			ivL_REALEClass, ecorePackage.getEBoolean(), "validateOptionsContainingHigh", 0, 1, IS_UNIQUE, IS_ORDERED);
+		addEParameter(op, ecorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, IS_UNIQUE, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEMap());
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		op = addEOperation(
+			ivL_REALEClass, ecorePackage.getEBoolean(), "validateOptionsContainingWidth", 0, 1, IS_UNIQUE, IS_ORDERED);
+		addEParameter(op, ecorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, IS_UNIQUE, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEMap());
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(ecorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, IS_UNIQUE, IS_ORDERED);
+
 		// Initialize enums and add enum literals
 		initEEnum(binaryDataEncodingEEnum, BinaryDataEncoding.class, "BinaryDataEncoding");
 		addEEnumLiteral(binaryDataEncodingEEnum, BinaryDataEncoding.B64);
@@ -3861,10 +4231,11 @@
 		addAnnotation(getED_Mixed(), source, new String[] { "name", "mixed", "kind", "elementWildcard" });
 		addAnnotation(getED_Reference(), source, new String[] { "namespace", "urn:hl7-org:v3", "kind", "element" });
 		addAnnotation(getED_Thumbnail(), source, new String[] { "namespace", "urn:hl7-org:v3", "kind", "element" });
-		addAnnotation(telEClass, source, new String[] { "kind", "mixed" });
+		addAnnotation(telEClass, source, new String[] { "kind", "mixed", "name", "" });
 		addAnnotation(getTEL_UseablePeriod(), source, new String[] { "namespace", "urn:hl7-org:v3" });
 		addAnnotation(getTEL_Use(), source, new String[] { "kind", "attribute" });
-		addAnnotation(getTEL_Mixed(), source, new String[] { "name", "mixed", "kind", "elementWildcard" });
+		addAnnotation(
+			getTEL_Mixed(), source, new String[] { "name", "mixed", "namespace", "", "kind", "elementWildcard" });
 		addAnnotation(
 			tsTypeEDataType, source,
 			new String[] { "pattern", "[0-9]{1,8}|([0-9]{9,14}|[0-9]{14,14}\\.[0-9]+)([+\\-][0-9]{1,4})?" });
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EDImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EDImpl.java
index 0091131..789948e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EDImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EDImpl.java
@@ -210,6 +210,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getMixed() {
 		if (mixed == null) {
 			mixed = new BasicFeatureMap(this, DatatypesPackage.ED__MIXED);
@@ -222,6 +223,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public TEL getReference() {
 		return (TEL) getMixed().get(DatatypesPackage.Literals.ED__REFERENCE, true);
 	}
@@ -240,6 +242,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setReference(TEL newReference) {
 		((FeatureMap.Internal) getMixed()).set(DatatypesPackage.Literals.ED__REFERENCE, newReference);
 	}
@@ -249,6 +252,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public ED getThumbnail() {
 		return (ED) getMixed().get(DatatypesPackage.Literals.ED__THUMBNAIL, true);
 	}
@@ -267,6 +271,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setThumbnail(ED newThumbnail) {
 		((FeatureMap.Internal) getMixed()).set(DatatypesPackage.Literals.ED__THUMBNAIL, newThumbnail);
 	}
@@ -276,6 +281,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getMediaType() {
 		return mediaType;
 	}
@@ -285,6 +291,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setMediaType(String newMediaType) {
 		String oldMediaType = mediaType;
 		mediaType = newMediaType;
@@ -303,6 +310,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetMediaType() {
 		String oldMediaType = mediaType;
 		boolean oldMediaTypeESet = mediaTypeESet;
@@ -321,6 +329,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetMediaType() {
 		return mediaTypeESet;
 	}
@@ -330,6 +339,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getLanguage() {
 		return language;
 	}
@@ -339,6 +349,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setLanguage(String newLanguage) {
 		String oldLanguage = language;
 		language = newLanguage;
@@ -353,6 +364,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CompressionAlgorithm getCompression() {
 		return compression;
 	}
@@ -362,6 +374,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCompression(CompressionAlgorithm newCompression) {
 		CompressionAlgorithm oldCompression = compression;
 		compression = newCompression == null
@@ -382,6 +395,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetCompression() {
 		CompressionAlgorithm oldCompression = compression;
 		boolean oldCompressionESet = compressionESet;
@@ -400,6 +414,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetCompression() {
 		return compressionESet;
 	}
@@ -409,6 +424,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public byte[] getIntegrityCheck() {
 		return integrityCheck;
 	}
@@ -418,6 +434,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setIntegrityCheck(byte[] newIntegrityCheck) {
 		byte[] oldIntegrityCheck = integrityCheck;
 		integrityCheck = newIntegrityCheck;
@@ -433,6 +450,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IntegrityCheckAlgorithm getIntegrityCheckAlgorithm() {
 		return integrityCheckAlgorithm;
 	}
@@ -442,6 +460,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setIntegrityCheckAlgorithm(IntegrityCheckAlgorithm newIntegrityCheckAlgorithm) {
 		IntegrityCheckAlgorithm oldIntegrityCheckAlgorithm = integrityCheckAlgorithm;
 		integrityCheckAlgorithm = newIntegrityCheckAlgorithm == null
@@ -462,6 +481,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetIntegrityCheckAlgorithm() {
 		IntegrityCheckAlgorithm oldIntegrityCheckAlgorithm = integrityCheckAlgorithm;
 		boolean oldIntegrityCheckAlgorithmESet = integrityCheckAlgorithmESet;
@@ -480,6 +500,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetIntegrityCheckAlgorithm() {
 		return integrityCheckAlgorithmESet;
 	}
@@ -698,7 +719,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (mixed: ");
 		result.append(mixed);
 		result.append(", mediaType: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EIVL_TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EIVL_TSImpl.java
index 78c355d..d934861 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EIVL_TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/EIVL_TSImpl.java
@@ -79,6 +79,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EIVL_event getEvent() {
 		return event;
 	}
@@ -108,6 +109,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setEvent(EIVL_event newEvent) {
 		if (newEvent != event) {
 			NotificationChain msgs = null;
@@ -133,6 +135,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_PQ getOffset() {
 		return offset;
 	}
@@ -162,6 +165,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setOffset(IVL_PQ newOffset) {
 		if (newOffset != offset) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENImpl.java
index 944c80f..baa3fc8 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENImpl.java
@@ -95,6 +95,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<EntityNameUse> getUses() {
 		if (uses == null) {
 			uses = new EDataTypeUniqueEList.Unsettable<EntityNameUse>(
@@ -108,6 +109,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetUses() {
 		if (uses != null) {
 			((InternalEList.Unsettable<?>) uses).unset();
@@ -119,6 +121,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetUses() {
 		return uses != null && ((InternalEList.Unsettable<?>) uses).isSet();
 	}
@@ -128,6 +131,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_TS getValidTime() {
 		return (IVL_TS) getMixed().get(DatatypesPackage.Literals.EN__VALID_TIME, true);
 	}
@@ -147,6 +151,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValidTime(IVL_TS newValidTime) {
 		((FeatureMap.Internal) getMixed()).set(DatatypesPackage.Literals.EN__VALID_TIME, newValidTime);
 	}
@@ -156,6 +161,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ENXP> getDelimiters() {
 		return getParts().list(DatatypesPackage.Literals.EN__DELIMITER);
 	}
@@ -165,6 +171,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ENXP> getFamilies() {
 		return getParts().list(DatatypesPackage.Literals.EN__FAMILY);
 	}
@@ -174,6 +181,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ENXP> getGivens() {
 		return getParts().list(DatatypesPackage.Literals.EN__GIVEN);
 	}
@@ -183,6 +191,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ENXP> getPrefixes() {
 		return getParts().list(DatatypesPackage.Literals.EN__PREFIX);
 	}
@@ -192,6 +201,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<ENXP> getSuffixes() {
 		return getParts().list(DatatypesPackage.Literals.EN__SUFFIX);
 	}
@@ -201,6 +211,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getParts() {
 		return (FeatureMap) getMixed().<FeatureMap.Entry> list(DatatypesPackage.Literals.EN__PART);
 	}
@@ -210,6 +221,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getMixed() {
 		if (mixed == null) {
 			mixed = new BasicFeatureMap(this, DatatypesPackage.EN__MIXED);
@@ -510,7 +522,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (use: ");
 		result.append(uses);
 		result.append(", mixed: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENXPImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENXPImpl.java
index b6320ab..6091904 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENXPImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/ENXPImpl.java
@@ -101,6 +101,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EntityNamePartType getPartType() {
 		return partType;
 	}
@@ -110,6 +111,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setPartType(EntityNamePartType newPartType) {
 		EntityNamePartType oldPartType = partType;
 		partType = newPartType == null
@@ -129,6 +131,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetPartType() {
 		EntityNamePartType oldPartType = partType;
 		boolean oldPartTypeESet = partTypeESet;
@@ -147,6 +150,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetPartType() {
 		return partTypeESet;
 	}
@@ -156,6 +160,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<EntityNamePartQualifier> getQualifiers() {
 		if (qualifiers == null) {
 			qualifiers = new EDataTypeUniqueEList.Unsettable<EntityNamePartQualifier>(
@@ -169,6 +174,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetQualifiers() {
 		if (qualifiers != null) {
 			((InternalEList.Unsettable<?>) qualifiers).unset();
@@ -180,6 +186,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetQualifiers() {
 		return qualifiers != null && ((InternalEList.Unsettable<?>) qualifiers).isSet();
 	}
@@ -265,7 +272,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (partType: ");
 		if (partTypeESet) {
 			result.append(partType);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IIImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IIImpl.java
index 33ab5c0..b4f2214 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IIImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IIImpl.java
@@ -141,6 +141,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getRoot() {
 		return root;
 	}
@@ -150,6 +151,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setRoot(String newRoot) {
 		String oldRoot = root;
 		root = newRoot;
@@ -163,6 +165,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getExtension() {
 		return extension;
 	}
@@ -172,6 +175,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setExtension(String newExtension) {
 		String oldExtension = extension;
 		extension = newExtension;
@@ -186,6 +190,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getAssigningAuthorityName() {
 		return assigningAuthorityName;
 	}
@@ -195,6 +200,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setAssigningAuthorityName(String newAssigningAuthorityName) {
 		String oldAssigningAuthorityName = assigningAuthorityName;
 		assigningAuthorityName = newAssigningAuthorityName;
@@ -211,6 +217,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getDisplayable() {
 		return displayable;
 	}
@@ -220,6 +227,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setDisplayable(Boolean newDisplayable) {
 		Boolean oldDisplayable = displayable;
 		displayable = newDisplayable;
@@ -346,7 +354,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (root: ");
 		result.append(root);
 		result.append(", extension: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/INTImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/INTImpl.java
index 609fe32..f174747 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/INTImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/INTImpl.java
@@ -79,6 +79,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BigInteger getValue() {
 		return value;
 	}
@@ -88,6 +89,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(BigInteger newValue) {
 		BigInteger oldValue = value;
 		value = newValue;
@@ -185,7 +187,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_INTImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_INTImpl.java
index 702db80..0abd681 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_INTImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_INTImpl.java
@@ -105,6 +105,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_INT getLow() {
 		return low;
 	}
@@ -134,6 +135,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setLow(IVXB_INT newLow) {
 		if (newLow != low) {
 			NotificationChain msgs = null;
@@ -159,6 +161,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public INT getCenter() {
 		return center;
 	}
@@ -188,6 +191,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCenter(INT newCenter) {
 		if (newCenter != center) {
 			NotificationChain msgs = null;
@@ -214,6 +218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_INT getHigh() {
 		return high;
 	}
@@ -243,6 +248,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setHigh(IVXB_INT newHigh) {
 		if (newHigh != high) {
 			NotificationChain msgs = null;
@@ -268,6 +274,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public INT getWidth() {
 		return width;
 	}
@@ -297,6 +304,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setWidth(INT newWidth) {
 		if (newWidth != width) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_PQImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_PQImpl.java
index 74e95e1..f1b171d 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_PQImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_PQImpl.java
@@ -105,6 +105,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_PQ getLow() {
 		return low;
 	}
@@ -134,6 +135,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setLow(IVXB_PQ newLow) {
 		if (newLow != low) {
 			NotificationChain msgs = null;
@@ -159,6 +161,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getCenter() {
 		return center;
 	}
@@ -188,6 +191,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCenter(PQ newCenter) {
 		if (newCenter != center) {
 			NotificationChain msgs = null;
@@ -214,6 +218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_PQ getHigh() {
 		return high;
 	}
@@ -243,6 +248,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setHigh(IVXB_PQ newHigh) {
 		if (newHigh != high) {
 			NotificationChain msgs = null;
@@ -268,6 +274,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getWidth() {
 		return width;
 	}
@@ -297,6 +304,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setWidth(PQ newWidth) {
 		if (newWidth != width) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_REALImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_REALImpl.java
new file mode 100644
index 0000000..752edb3
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_REALImpl.java
@@ -0,0 +1,469 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes.impl;
+
+import java.util.Map;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.DiagnosticChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
+import org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL;
+import org.eclipse.mdht.uml.hl7.datatypes.REAL;
+
+import org.eclipse.mdht.uml.hl7.datatypes.operations.IVL_REALOperations;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>IVL REAL</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl#getLow <em>Low</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl#getCenter <em>Center</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl#getHigh <em>High</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVL_REALImpl#getWidth <em>Width</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IVL_REALImpl extends SXCM_REALImpl implements IVL_REAL {
+	/**
+	 * The cached value of the '{@link #getLow() <em>Low</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLow()
+	 * @generated
+	 * @ordered
+	 */
+	protected IVL_REAL low;
+
+	/**
+	 * The cached value of the '{@link #getCenter() <em>Center</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCenter()
+	 * @generated
+	 * @ordered
+	 */
+	protected REAL center;
+
+	/**
+	 * The cached value of the '{@link #getHigh() <em>High</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHigh()
+	 * @generated
+	 * @ordered
+	 */
+	protected IVL_REAL high;
+
+	/**
+	 * The cached value of the '{@link #getWidth() <em>Width</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected REAL width;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IVL_REALImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return DatatypesPackage.Literals.IVL_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public IVL_REAL getLow() {
+		return low;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetLow(IVL_REAL newLow, NotificationChain msgs) {
+		IVL_REAL oldLow = low;
+		low = newLow;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(
+				this, Notification.SET, DatatypesPackage.IVL_REAL__LOW, oldLow, newLow);
+			if (msgs == null) {
+				msgs = notification;
+			} else {
+				msgs.add(notification);
+			}
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setLow(IVL_REAL newLow) {
+		if (newLow != low) {
+			NotificationChain msgs = null;
+			if (low != null) {
+				msgs = ((InternalEObject) low).eInverseRemove(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__LOW, null, msgs);
+			}
+			if (newLow != null) {
+				msgs = ((InternalEObject) newLow).eInverseAdd(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__LOW, null, msgs);
+			}
+			msgs = basicSetLow(newLow, msgs);
+			if (msgs != null) {
+				msgs.dispatch();
+			}
+		} else if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, DatatypesPackage.IVL_REAL__LOW, newLow, newLow));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public REAL getCenter() {
+		return center;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetCenter(REAL newCenter, NotificationChain msgs) {
+		REAL oldCenter = center;
+		center = newCenter;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(
+				this, Notification.SET, DatatypesPackage.IVL_REAL__CENTER, oldCenter, newCenter);
+			if (msgs == null) {
+				msgs = notification;
+			} else {
+				msgs.add(notification);
+			}
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setCenter(REAL newCenter) {
+		if (newCenter != center) {
+			NotificationChain msgs = null;
+			if (center != null) {
+				msgs = ((InternalEObject) center).eInverseRemove(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__CENTER, null, msgs);
+			}
+			if (newCenter != null) {
+				msgs = ((InternalEObject) newCenter).eInverseAdd(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__CENTER, null, msgs);
+			}
+			msgs = basicSetCenter(newCenter, msgs);
+			if (msgs != null) {
+				msgs.dispatch();
+			}
+		} else if (eNotificationRequired()) {
+			eNotify(
+				new ENotificationImpl(this, Notification.SET, DatatypesPackage.IVL_REAL__CENTER, newCenter, newCenter));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public IVL_REAL getHigh() {
+		return high;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetHigh(IVL_REAL newHigh, NotificationChain msgs) {
+		IVL_REAL oldHigh = high;
+		high = newHigh;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(
+				this, Notification.SET, DatatypesPackage.IVL_REAL__HIGH, oldHigh, newHigh);
+			if (msgs == null) {
+				msgs = notification;
+			} else {
+				msgs.add(notification);
+			}
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setHigh(IVL_REAL newHigh) {
+		if (newHigh != high) {
+			NotificationChain msgs = null;
+			if (high != null) {
+				msgs = ((InternalEObject) high).eInverseRemove(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__HIGH, null, msgs);
+			}
+			if (newHigh != null) {
+				msgs = ((InternalEObject) newHigh).eInverseAdd(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__HIGH, null, msgs);
+			}
+			msgs = basicSetHigh(newHigh, msgs);
+			if (msgs != null) {
+				msgs.dispatch();
+			}
+		} else if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, DatatypesPackage.IVL_REAL__HIGH, newHigh, newHigh));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public REAL getWidth() {
+		return width;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetWidth(REAL newWidth, NotificationChain msgs) {
+		REAL oldWidth = width;
+		width = newWidth;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(
+				this, Notification.SET, DatatypesPackage.IVL_REAL__WIDTH, oldWidth, newWidth);
+			if (msgs == null) {
+				msgs = notification;
+			} else {
+				msgs.add(notification);
+			}
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setWidth(REAL newWidth) {
+		if (newWidth != width) {
+			NotificationChain msgs = null;
+			if (width != null) {
+				msgs = ((InternalEObject) width).eInverseRemove(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__WIDTH, null, msgs);
+			}
+			if (newWidth != null) {
+				msgs = ((InternalEObject) newWidth).eInverseAdd(
+					this, EOPPOSITE_FEATURE_BASE - DatatypesPackage.IVL_REAL__WIDTH, null, msgs);
+			}
+			msgs = basicSetWidth(newWidth, msgs);
+			if (msgs != null) {
+				msgs.dispatch();
+			}
+		} else if (eNotificationRequired()) {
+			eNotify(
+				new ENotificationImpl(this, Notification.SET, DatatypesPackage.IVL_REAL__WIDTH, newWidth, newWidth));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateOptionsContainingLow(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		return IVL_REALOperations.validateOptionsContainingLow(this, diagnostics, context);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateOptionsContainingCenter(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		return IVL_REALOperations.validateOptionsContainingCenter(this, diagnostics, context);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateOptionsContainingHigh(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		return IVL_REALOperations.validateOptionsContainingHigh(this, diagnostics, context);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateOptionsContainingWidth(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		return IVL_REALOperations.validateOptionsContainingWidth(this, diagnostics, context);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case DatatypesPackage.IVL_REAL__LOW:
+				return basicSetLow(null, msgs);
+			case DatatypesPackage.IVL_REAL__CENTER:
+				return basicSetCenter(null, msgs);
+			case DatatypesPackage.IVL_REAL__HIGH:
+				return basicSetHigh(null, msgs);
+			case DatatypesPackage.IVL_REAL__WIDTH:
+				return basicSetWidth(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case DatatypesPackage.IVL_REAL__LOW:
+				return getLow();
+			case DatatypesPackage.IVL_REAL__CENTER:
+				return getCenter();
+			case DatatypesPackage.IVL_REAL__HIGH:
+				return getHigh();
+			case DatatypesPackage.IVL_REAL__WIDTH:
+				return getWidth();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case DatatypesPackage.IVL_REAL__LOW:
+				setLow((IVL_REAL) newValue);
+				return;
+			case DatatypesPackage.IVL_REAL__CENTER:
+				setCenter((REAL) newValue);
+				return;
+			case DatatypesPackage.IVL_REAL__HIGH:
+				setHigh((IVL_REAL) newValue);
+				return;
+			case DatatypesPackage.IVL_REAL__WIDTH:
+				setWidth((REAL) newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.IVL_REAL__LOW:
+				setLow((IVL_REAL) null);
+				return;
+			case DatatypesPackage.IVL_REAL__CENTER:
+				setCenter((REAL) null);
+				return;
+			case DatatypesPackage.IVL_REAL__HIGH:
+				setHigh((IVL_REAL) null);
+				return;
+			case DatatypesPackage.IVL_REAL__WIDTH:
+				setWidth((REAL) null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.IVL_REAL__LOW:
+				return low != null;
+			case DatatypesPackage.IVL_REAL__CENTER:
+				return center != null;
+			case DatatypesPackage.IVL_REAL__HIGH:
+				return high != null;
+			case DatatypesPackage.IVL_REAL__WIDTH:
+				return width != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+} // IVL_REALImpl
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_TSImpl.java
index e7fa49c..9d1b587 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVL_TSImpl.java
@@ -106,6 +106,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_TS getLow() {
 		return low;
 	}
@@ -135,6 +136,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setLow(IVXB_TS newLow) {
 		if (newLow != low) {
 			NotificationChain msgs = null;
@@ -160,6 +162,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public TS getCenter() {
 		return center;
 	}
@@ -189,6 +192,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCenter(TS newCenter) {
 		if (newCenter != center) {
 			NotificationChain msgs = null;
@@ -215,6 +219,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVXB_TS getHigh() {
 		return high;
 	}
@@ -244,6 +249,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setHigh(IVXB_TS newHigh) {
 		if (newHigh != high) {
 			NotificationChain msgs = null;
@@ -269,6 +275,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getWidth() {
 		return width;
 	}
@@ -298,6 +305,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setWidth(PQ newWidth) {
 		if (newWidth != width) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_INTImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_INTImpl.java
index c3d589b..7b82b47 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_INTImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_INTImpl.java
@@ -74,6 +74,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getInclusive() {
 		return inclusive;
 	}
@@ -83,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setInclusive(Boolean newInclusive) {
 		Boolean oldInclusive = inclusive;
 		inclusive = newInclusive;
@@ -164,7 +166,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (inclusive: ");
 		result.append(inclusive);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_PQImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_PQImpl.java
index b0e20bd..20e3776 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_PQImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_PQImpl.java
@@ -74,6 +74,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getInclusive() {
 		return inclusive;
 	}
@@ -83,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setInclusive(Boolean newInclusive) {
 		Boolean oldInclusive = inclusive;
 		inclusive = newInclusive;
@@ -164,7 +166,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (inclusive: ");
 		result.append(inclusive);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_REALImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_REALImpl.java
new file mode 100644
index 0000000..d1a4b2d
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_REALImpl.java
@@ -0,0 +1,171 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
+import org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>IVXB REAL</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.IVXB_REALImpl#getInclusive <em>Inclusive</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IVXB_REALImpl extends REALImpl implements IVXB_REAL {
+	/**
+	 * The default value of the '{@link #getInclusive() <em>Inclusive</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getInclusive()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Boolean INCLUSIVE_EDEFAULT = Boolean.TRUE;
+
+	/**
+	 * The cached value of the '{@link #getInclusive() <em>Inclusive</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getInclusive()
+	 * @generated
+	 * @ordered
+	 */
+	protected Boolean inclusive = INCLUSIVE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IVXB_REALImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return DatatypesPackage.Literals.IVXB_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Boolean getInclusive() {
+		return inclusive;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setInclusive(Boolean newInclusive) {
+		Boolean oldInclusive = inclusive;
+		inclusive = newInclusive;
+		if (eNotificationRequired()) {
+			eNotify(
+				new ENotificationImpl(
+					this, Notification.SET, DatatypesPackage.IVXB_REAL__INCLUSIVE, oldInclusive, inclusive));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case DatatypesPackage.IVXB_REAL__INCLUSIVE:
+				return getInclusive();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case DatatypesPackage.IVXB_REAL__INCLUSIVE:
+				setInclusive((Boolean) newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.IVXB_REAL__INCLUSIVE:
+				setInclusive(INCLUSIVE_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.IVXB_REAL__INCLUSIVE:
+				return INCLUSIVE_EDEFAULT == null
+						? inclusive != null
+						: !INCLUSIVE_EDEFAULT.equals(inclusive);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (inclusive: ");
+		result.append(inclusive);
+		result.append(')');
+		return result.toString();
+	}
+
+} // IVXB_REALImpl
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_TSImpl.java
index d6a0fdf..c4bf43d 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/IVXB_TSImpl.java
@@ -74,6 +74,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getInclusive() {
 		return inclusive;
 	}
@@ -83,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setInclusive(Boolean newInclusive) {
 		Boolean oldInclusive = inclusive;
 		inclusive = newInclusive;
@@ -164,7 +166,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (inclusive: ");
 		result.append(inclusive);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/MOImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/MOImpl.java
index 72b09e0..a31b76c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/MOImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/MOImpl.java
@@ -100,6 +100,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BigDecimal getValue() {
 		return value;
 	}
@@ -109,6 +110,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(BigDecimal newValue) {
 		BigDecimal oldValue = value;
 		value = newValue;
@@ -122,6 +124,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCurrency() {
 		return currency;
 	}
@@ -131,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCurrency(String newCurrency) {
 		String oldCurrency = currency;
 		currency = newCurrency;
@@ -241,7 +245,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(", currency: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PIVL_TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PIVL_TSImpl.java
index 35c669e..2af41fb 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PIVL_TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PIVL_TSImpl.java
@@ -140,6 +140,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public IVL_TS getPhase() {
 		return phase;
 	}
@@ -169,6 +170,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setPhase(IVL_TS newPhase) {
 		if (newPhase != phase) {
 			NotificationChain msgs = null;
@@ -194,6 +196,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getPeriod() {
 		return period;
 	}
@@ -223,6 +226,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setPeriod(PQ newPeriod) {
 		if (newPeriod != period) {
 			NotificationChain msgs = null;
@@ -249,6 +253,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public CalendarCycle getAlignment() {
 		return alignment;
 	}
@@ -258,6 +263,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setAlignment(CalendarCycle newAlignment) {
 		CalendarCycle oldAlignment = alignment;
 		alignment = newAlignment == null
@@ -278,6 +284,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetAlignment() {
 		CalendarCycle oldAlignment = alignment;
 		boolean oldAlignmentESet = alignmentESet;
@@ -296,6 +303,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetAlignment() {
 		return alignmentESet;
 	}
@@ -305,6 +313,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public Boolean getInstitutionSpecified() {
 		return institutionSpecified;
 	}
@@ -314,6 +323,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setInstitutionSpecified(Boolean newInstitutionSpecified) {
 		Boolean oldInstitutionSpecified = institutionSpecified;
 		institutionSpecified = newInstitutionSpecified;
@@ -332,6 +342,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetInstitutionSpecified() {
 		Boolean oldInstitutionSpecified = institutionSpecified;
 		boolean oldInstitutionSpecifiedESet = institutionSpecifiedESet;
@@ -350,6 +361,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetInstitutionSpecified() {
 		return institutionSpecifiedESet;
 	}
@@ -469,7 +481,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (alignment: ");
 		if (alignmentESet) {
 			result.append(alignment);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQImpl.java
index b59470d..9275338 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQImpl.java
@@ -116,6 +116,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BigDecimal getValue() {
 		return value;
 	}
@@ -125,6 +126,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(BigDecimal newValue) {
 		BigDecimal oldValue = value;
 		value = newValue;
@@ -147,6 +149,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getUnit() {
 		return unit;
 	}
@@ -156,6 +159,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setUnit(String newUnit) {
 		String oldUnit = unit;
 		unit = newUnit;
@@ -169,6 +173,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<PQR> getTranslations() {
 		if (translations == null) {
 			translations = new EObjectContainmentEList<PQR>(PQR.class, this, DatatypesPackage.PQ__TRANSLATION);
@@ -285,7 +290,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(", unit: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQRImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQRImpl.java
index 4d098fb..8ea7237 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQRImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/PQRImpl.java
@@ -77,6 +77,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BigDecimal getValue() {
 		return value;
 	}
@@ -86,6 +87,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(BigDecimal newValue) {
 		BigDecimal oldValue = value;
 		value = newValue;
@@ -174,7 +176,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/REALImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/REALImpl.java
index 7f0693d..caf7e81 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/REALImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/REALImpl.java
@@ -79,6 +79,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public BigDecimal getValue() {
 		return value;
 	}
@@ -88,6 +89,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(BigDecimal newValue) {
 		BigDecimal oldValue = value;
 		value = newValue;
@@ -185,7 +187,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_PQ_PQImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_PQ_PQImpl.java
index 1a48c9d..172f25e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_PQ_PQImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_PQ_PQImpl.java
@@ -82,6 +82,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getNumerator() {
 		return numerator;
 	}
@@ -111,6 +112,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setNumerator(PQ newNumerator) {
 		if (newNumerator != numerator) {
 			NotificationChain msgs = null;
@@ -138,6 +140,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public PQ getDenominator() {
 		return denominator;
 	}
@@ -167,6 +170,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setDenominator(PQ newDenominator) {
 		if (newDenominator != denominator) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_QTY_QTYImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_QTY_QTYImpl.java
index bc7483f..6d0c822 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_QTY_QTYImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/RTO_QTY_QTYImpl.java
@@ -82,6 +82,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public QTY getNumerator() {
 		return numerator;
 	}
@@ -111,6 +112,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setNumerator(QTY newNumerator) {
 		if (newNumerator != numerator) {
 			NotificationChain msgs = null;
@@ -138,6 +140,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public QTY getDenominator() {
 		return denominator;
 	}
@@ -167,6 +170,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setDenominator(QTY newDenominator) {
 		if (newDenominator != denominator) {
 			NotificationChain msgs = null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SCImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SCImpl.java
index 8ca2484..6ce3037 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SCImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SCImpl.java
@@ -158,6 +158,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCode() {
 		return code;
 	}
@@ -167,6 +168,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCode(String newCode) {
 		String oldCode = code;
 		code = newCode;
@@ -180,6 +182,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystem() {
 		return codeSystem;
 	}
@@ -189,6 +192,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystem(String newCodeSystem) {
 		String oldCodeSystem = codeSystem;
 		codeSystem = newCodeSystem;
@@ -204,6 +208,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystemName() {
 		return codeSystemName;
 	}
@@ -213,6 +218,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystemName(String newCodeSystemName) {
 		String oldCodeSystemName = codeSystemName;
 		codeSystemName = newCodeSystemName;
@@ -228,6 +234,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getCodeSystemVersion() {
 		return codeSystemVersion;
 	}
@@ -237,6 +244,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setCodeSystemVersion(String newCodeSystemVersion) {
 		String oldCodeSystemVersion = codeSystemVersion;
 		codeSystemVersion = newCodeSystemVersion;
@@ -253,6 +261,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getDisplayName() {
 		return displayName;
 	}
@@ -262,6 +271,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setDisplayName(String newDisplayName) {
 		String oldDisplayName = displayName;
 		displayName = newDisplayName;
@@ -391,7 +401,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (code: ");
 		result.append(code);
 		result.append(", codeSystem: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_INTImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_INTImpl.java
index 9c05f7d..0137251 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_INTImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_INTImpl.java
@@ -84,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SetOperator getOperator() {
 		return operator;
 	}
@@ -93,6 +94,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setOperator(SetOperator newOperator) {
 		SetOperator oldOperator = operator;
 		operator = newOperator == null
@@ -113,6 +115,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetOperator() {
 		SetOperator oldOperator = operator;
 		boolean oldOperatorESet = operatorESet;
@@ -131,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetOperator() {
 		return operatorESet;
 	}
@@ -204,7 +208,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (operator: ");
 		if (operatorESet) {
 			result.append(operator);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_PQImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_PQImpl.java
index 040a49f..c9b8fab 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_PQImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_PQImpl.java
@@ -84,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SetOperator getOperator() {
 		return operator;
 	}
@@ -93,6 +94,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setOperator(SetOperator newOperator) {
 		SetOperator oldOperator = operator;
 		operator = newOperator == null
@@ -113,6 +115,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetOperator() {
 		SetOperator oldOperator = operator;
 		boolean oldOperatorESet = operatorESet;
@@ -131,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetOperator() {
 		return operatorESet;
 	}
@@ -204,7 +208,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (operator: ");
 		if (operatorESet) {
 			result.append(operator);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_REALImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_REALImpl.java
new file mode 100644
index 0000000..866d3cc
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_REALImpl.java
@@ -0,0 +1,173 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
+import org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL;
+
+import org.eclipse.mdht.uml.hl7.vocab.SetOperator;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>SXCM REAL</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.impl.SXCM_REALImpl#getOperator <em>Operator</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class SXCM_REALImpl extends REALImpl implements SXCM_REAL {
+	/**
+	 * The default value of the '{@link #getOperator() <em>Operator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getOperator()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final SetOperator OPERATOR_EDEFAULT = SetOperator.I;
+
+	/**
+	 * The cached value of the '{@link #getOperator() <em>Operator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getOperator()
+	 * @generated
+	 * @ordered
+	 */
+	protected SetOperator operator = OPERATOR_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected SXCM_REALImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return DatatypesPackage.Literals.SXCM_REAL;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public SetOperator getOperator() {
+		return operator;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setOperator(SetOperator newOperator) {
+		SetOperator oldOperator = operator;
+		operator = newOperator == null
+				? OPERATOR_EDEFAULT
+				: newOperator;
+		if (eNotificationRequired()) {
+			eNotify(
+				new ENotificationImpl(
+					this, Notification.SET, DatatypesPackage.SXCM_REAL__OPERATOR, oldOperator, operator));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case DatatypesPackage.SXCM_REAL__OPERATOR:
+				return getOperator();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case DatatypesPackage.SXCM_REAL__OPERATOR:
+				setOperator((SetOperator) newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.SXCM_REAL__OPERATOR:
+				setOperator(OPERATOR_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case DatatypesPackage.SXCM_REAL__OPERATOR:
+				return operator != OPERATOR_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (operator: ");
+		result.append(operator);
+		result.append(')');
+		return result.toString();
+	}
+
+} // SXCM_REALImpl
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_TSImpl.java
index 646e889..680384b 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/SXCM_TSImpl.java
@@ -84,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public SetOperator getOperator() {
 		return operator;
 	}
@@ -93,6 +94,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setOperator(SetOperator newOperator) {
 		SetOperator oldOperator = operator;
 		operator = newOperator == null
@@ -113,6 +115,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetOperator() {
 		SetOperator oldOperator = operator;
 		boolean oldOperatorESet = operatorESet;
@@ -131,6 +134,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetOperator() {
 		return operatorESet;
 	}
@@ -204,7 +208,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (operator: ");
 		if (operatorESet) {
 			result.append(operator);
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TELImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TELImpl.java
index 75b774c..52d4665 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TELImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TELImpl.java
@@ -97,6 +97,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<SXCM_TS> getUseablePeriods() {
 		if (useablePeriods == null) {
 			useablePeriods = new EObjectContainmentEList<SXCM_TS>(
@@ -110,6 +111,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EList<TelecommunicationAddressUse> getUses() {
 		if (uses == null) {
 			uses = new EDataTypeUniqueEList.Unsettable<TelecommunicationAddressUse>(
@@ -123,6 +125,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void unsetUses() {
 		if (uses != null) {
 			((InternalEList.Unsettable<?>) uses).unset();
@@ -134,6 +137,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public boolean isSetUses() {
 		return uses != null && ((InternalEList.Unsettable<?>) uses).isSet();
 	}
@@ -143,6 +147,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public FeatureMap getMixed() {
 		if (mixed == null) {
 			mixed = new BasicFeatureMap(this, DatatypesPackage.TEL__MIXED);
@@ -270,7 +275,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (use: ");
 		result.append(uses);
 		result.append(", mixed: ");
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TSImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TSImpl.java
index 50dcd92..905b33e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TSImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/TSImpl.java
@@ -74,6 +74,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getValue() {
 		return value;
 	}
@@ -83,6 +84,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(String newValue) {
 		String oldValue = value;
 		value = newValue;
@@ -162,7 +164,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/URLImpl.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/URLImpl.java
index 89960d9..c2bad8c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/URLImpl.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/impl/URLImpl.java
@@ -78,6 +78,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public String getValue() {
 		return value;
 	}
@@ -87,6 +88,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public void setValue(String newValue) {
 		String oldValue = value;
 		value = newValue;
@@ -175,7 +177,7 @@
 			return super.toString();
 		}
 
-		StringBuffer result = new StringBuffer(super.toString());
+		StringBuilder result = new StringBuilder(super.toString());
 		result.append(" (value: ");
 		result.append(value);
 		result.append(')');
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ADOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ADOperations.java
index e77c2aa..91c01aa 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ADOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ADOperations.java
@@ -20,7 +20,6 @@
 import org.eclipse.mdht.uml.hl7.datatypes.AD;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesFactory;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.mdht.uml.hl7.vocab.AddressPartType;
 import org.eclipse.ocl.ParserException;
@@ -104,12 +103,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -138,7 +132,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -151,23 +145,17 @@
 	 * @generated
 	 */
 	public static boolean validateDelimiter(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDelimiter", "ERROR");
-
-		if (VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -202,7 +190,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -215,23 +203,17 @@
 	 * @generated
 	 */
 	public static boolean validateCountry(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADCountry", "ERROR");
-
-		if (VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_COUNTRY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -266,7 +248,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -279,23 +261,17 @@
 	 * @generated
 	 */
 	public static boolean validateState(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADState", "ERROR");
-
-		if (VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_STATE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -330,7 +306,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -343,23 +319,17 @@
 	 * @generated
 	 */
 	public static boolean validateCounty(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADCounty", "ERROR");
-
-		if (VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_COUNTY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -394,7 +364,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -407,23 +377,17 @@
 	 * @generated
 	 */
 	public static boolean validateCity(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADCity", "ERROR");
-
-		if (VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CITY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -458,7 +422,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -471,23 +435,17 @@
 	 * @generated
 	 */
 	public static boolean validatePostalCode(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADPostalCode", "ERROR");
-
-		if (VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_POSTAL_CODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -522,7 +480,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -535,23 +493,17 @@
 	 * @generated
 	 */
 	public static boolean validateStreetAddressLine(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADStreetAddressLine", "ERROR");
-
-		if (VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_STREET_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -587,7 +539,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -600,23 +552,17 @@
 	 * @generated
 	 */
 	public static boolean validateHouseNumber(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADHouseNumber", "ERROR");
-
-		if (VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_HOUSE_NUMBER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -651,7 +597,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -664,24 +610,17 @@
 	 * @generated
 	 */
 	public static boolean validateHouseNumberNumeric(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADHouseNumberNumeric", "ERROR");
-
-		if (VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_HOUSE_NUMBER_NUMERIC__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -717,7 +656,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -730,23 +669,17 @@
 	 * @generated
 	 */
 	public static boolean validateDirection(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDirection", "ERROR");
-
-		if (VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DIRECTION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -781,7 +714,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -794,23 +727,17 @@
 	 * @generated
 	 */
 	public static boolean validateStreetName(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADStreetName", "ERROR");
-
-		if (VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_STREET_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -845,7 +772,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -858,23 +785,17 @@
 	 * @generated
 	 */
 	public static boolean validateStreetNameBase(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADStreetNameBase", "ERROR");
-
-		if (VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_STREET_NAME_BASE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -909,7 +830,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -922,23 +843,17 @@
 	 * @generated
 	 */
 	public static boolean validateStreetNameType(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADStreetNameType", "ERROR");
-
-		if (VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_STREET_NAME_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -973,7 +888,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -986,23 +901,17 @@
 	 * @generated
 	 */
 	public static boolean validateAdditionalLocator(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADAdditionalLocator", "ERROR");
-
-		if (VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_ADDITIONAL_LOCATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1038,7 +947,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1051,23 +960,17 @@
 	 * @generated
 	 */
 	public static boolean validateUnitID(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADUnitID", "ERROR");
-
-		if (VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_UNIT_ID__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1102,7 +1005,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1115,23 +1018,17 @@
 	 * @generated
 	 */
 	public static boolean validateUnitType(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADUnitType", "ERROR");
-
-		if (VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_UNIT_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1166,7 +1063,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1179,23 +1076,17 @@
 	 * @generated
 	 */
 	public static boolean validateCareOf(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADCareOf", "ERROR");
-
-		if (VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CARE_OF__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1230,7 +1121,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1243,23 +1134,17 @@
 	 * @generated
 	 */
 	public static boolean validateCensusTract(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADCensusTract", "ERROR");
-
-		if (VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CENSUS_TRACT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1294,7 +1179,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1307,24 +1192,17 @@
 	 * @generated
 	 */
 	public static boolean validateDeliveryAddressLine(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryAddressLine", "ERROR");
-
-		if (VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_ADDRESS_LINE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1360,7 +1238,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1374,24 +1252,17 @@
 	 */
 	public static boolean validateDeliveryInstallationType(AD ad, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryInstallationType", "ERROR");
-
-		if (VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(
-			VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_INSTALLATION_TYPE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1427,7 +1298,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1441,24 +1312,17 @@
 	 */
 	public static boolean validateDeliveryInstallationArea(AD ad, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryInstallationArea", "ERROR");
-
-		if (VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(
-			VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_INSTALLATION_AREA__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1494,7 +1358,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1508,25 +1372,17 @@
 	 */
 	public static boolean validateDeliveryInstallationQualifier(AD ad, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryInstallationQualifier", "ERROR");
-
-		if (VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(
-							VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(
-			VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_INSTALLATION_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1562,7 +1418,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1575,23 +1431,17 @@
 	 * @generated
 	 */
 	public static boolean validateDeliveryMode(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryMode", "ERROR");
-
-		if (VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_MODE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1626,7 +1476,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1640,24 +1490,17 @@
 	 */
 	public static boolean validateDeliveryModeIdentifier(AD ad, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADDeliveryModeIdentifier", "ERROR");
-
-		if (VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIVERY_MODE_IDENTIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1693,7 +1536,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1707,24 +1550,17 @@
 	 */
 	public static boolean validateBuildingNumberSuffix(AD ad, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADBuildingNumberSuffix", "ERROR");
-
-		if (VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_BUILDING_NUMBER_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1760,7 +1596,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1773,23 +1609,17 @@
 	 * @generated
 	 */
 	public static boolean validatePostBox(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADPostBox", "ERROR");
-
-		if (VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_POST_BOX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -1824,7 +1654,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -1837,23 +1667,17 @@
 	 * @generated
 	 */
 	public static boolean validatePrecinct(AD ad, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ADPrecinct", "ERROR");
-
-		if (VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.AD);
-				try {
-					VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.AD);
+			try {
+				VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ad)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_PRECINCT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ad)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ANYOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ANYOperations.java
index ef253d4..bd19c1e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ANYOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ANYOperations.java
@@ -12,7 +12,6 @@
 
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.mdht.uml.hl7.datatypes.ANY;
-import org.eclipse.ocl.ecore.OCL;
 
 /**
  * <!-- begin-user-doc -->
@@ -34,20 +33,6 @@
  */
 public class ANYOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BLOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BLOperations.java
index 77274ab..d955b63 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BLOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BLOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.BL;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +86,17 @@
 	 * @generated
 	 */
 	public static boolean validateBL(BL bl, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "BLBL", "ERROR");
-
-		if (VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.BL);
-				try {
-					VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.BL);
+			try {
+				VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(bl)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_BL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(bl)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BNOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BNOperations.java
index ab281a4..a5e95a8 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BNOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/BNOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.BN;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -39,20 +38,6 @@
  */
 public class BNOperations extends BLOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -79,7 +64,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +77,17 @@
 	 * @generated
 	 */
 	public static boolean validateNullFlavor(BN bn, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "BNNullFlavor", "ERROR");
-
-		if (VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.BN);
-				try {
-					VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.BN);
+			try {
+				VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(bn)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_NULL_FLAVOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(bn)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CEOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CEOperations.java
index 28c4149..2932662 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CEOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CEOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.CE;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +86,17 @@
 	 * @generated
 	 */
 	public static boolean validateQualifier(CE ce, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CEQualifier", "ERROR");
-
-		if (VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CE);
-				try {
-					VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CE);
+			try {
+				VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ce)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_QUALIFIER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ce)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CROperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CROperations.java
index 9d0ae7b..00343df 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CROperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CROperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.CR;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +86,17 @@
 	 * @generated
 	 */
 	public static boolean validateCR(CR cr, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CRCR", "ERROR");
-
-		if (VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CR);
-				try {
-					VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CR);
+			try {
+				VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cr)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cr)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CSOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CSOperations.java
index 308c407..297d4d0 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CSOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CSOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.CS;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -43,20 +42,6 @@
  */
 public class CSOperations extends CVOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -83,7 +68,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -96,23 +81,17 @@
 	 * @generated
 	 */
 	public static boolean validateOriginalText(CS cs, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CSOriginalText", "ERROR");
-
-		if (VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CS);
-				try {
-					VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CS);
+			try {
+				VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cs)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cs)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -147,7 +126,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -160,23 +139,17 @@
 	 * @generated
 	 */
 	public static boolean validateCodeSystem(CS cs, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CSCodeSystem", "ERROR");
-
-		if (VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CS);
-				try {
-					VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CS);
+			try {
+				VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cs)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cs)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -211,7 +184,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -224,23 +197,17 @@
 	 * @generated
 	 */
 	public static boolean validateCodeSystemName(CS cs, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CSCodeSystemName", "ERROR");
-
-		if (VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CS);
-				try {
-					VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CS);
+			try {
+				VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cs)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cs)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -275,7 +242,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -288,23 +255,17 @@
 	 * @generated
 	 */
 	public static boolean validateCodeSystemVersion(CS cs, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CSCodeSystemVersion", "ERROR");
-
-		if (VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CS);
-				try {
-					VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CS);
+			try {
+				VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cs)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CODE_SYSTEM_VERSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cs)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -340,7 +301,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -353,23 +314,17 @@
 	 * @generated
 	 */
 	public static boolean validateDisplayName(CS cs, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CSDisplayName", "ERROR");
-
-		if (VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CS);
-				try {
-					VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CS);
+			try {
+				VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cs)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DISPLAY_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cs)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CVOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CVOperations.java
index 5d16795..680a73e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CVOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/CVOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.CV;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -39,20 +38,6 @@
  */
 public class CVOperations extends CEOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -79,7 +64,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +77,17 @@
 	 * @generated
 	 */
 	public static boolean validateTranslation(CV cv, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "CVTranslation", "ERROR");
-
-		if (VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.CV);
-				try {
-					VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.CV);
+			try {
+				VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(cv)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(cv)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EDOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EDOperations.java
index 72ceff1..74a6ea4 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EDOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EDOperations.java
@@ -19,7 +19,6 @@
 import org.eclipse.emf.ecore.util.FeatureMapUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.ED;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -52,12 +51,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -86,7 +80,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -99,23 +93,17 @@
 	 * @generated
 	 */
 	public static boolean validateThumbnailThumbnail(ED ed, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "EDThumbnailThumbnail", "ERROR");
-
-		if (VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ED);
-				try {
-					VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ED);
+			try {
+				VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ed)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_THUMBNAIL_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ed)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EIVL_eventOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EIVL_eventOperations.java
index ace9694..50a8082 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EIVL_eventOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/EIVL_eventOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.EIVL_event;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.mdht.uml.hl7.vocab.TimingEvent;
 import org.eclipse.ocl.ParserException;
@@ -45,20 +44,6 @@
  */
 public class EIVL_eventOperations extends CEOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -85,7 +70,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -99,24 +84,17 @@
 	 */
 	public static boolean validateOriginalText(EIVL_event eivL_event, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "EIVL_eventOriginalText", "ERROR");
-
-		if (VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
-				try {
-					VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
+			try {
+				VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			eivL_event)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_ORIGINAL_TEXT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(eivL_event)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -152,7 +130,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -166,23 +144,17 @@
 	 */
 	public static boolean validateTranslation(EIVL_event eivL_event, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "EIVL_eventTranslation", "ERROR");
-
-		if (VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
-				try {
-					VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
+			try {
+				VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(eivL_event)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_TRANSLATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(eivL_event)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -218,7 +190,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -232,23 +204,17 @@
 	 */
 	public static boolean validateCodeSystem(EIVL_event eivL_event, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "EIVL_eventCodeSystem", "ERROR");
-
-		if (VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
-				try {
-					VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
+			try {
+				VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(eivL_event)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CODE_SYSTEM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(eivL_event)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -284,7 +250,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -298,24 +264,17 @@
 	 */
 	public static boolean validateCodeSystemName(EIVL_event eivL_event, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "EIVL_eventCodeSystemName", "ERROR");
-
-		if (VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
-				try {
-					VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EIVL_EVENT);
+			try {
+				VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			eivL_event)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_CODE_SYSTEM_NAME__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(eivL_event)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ENOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ENOperations.java
index 4ec1169..c862f5b 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ENOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ENOperations.java
@@ -20,7 +20,6 @@
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesFactory;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.EN;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.mdht.uml.hl7.vocab.EntityNamePartType;
 import org.eclipse.ocl.ParserException;
@@ -61,12 +60,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -95,7 +89,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -108,23 +102,17 @@
 	 * @generated
 	 */
 	public static boolean validateDelimiter(EN en, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ENDelimiter", "ERROR");
-
-		if (VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EN);
-				try {
-					VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EN);
+			try {
+				VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(en)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DELIMITER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(en)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -159,7 +147,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -172,23 +160,17 @@
 	 * @generated
 	 */
 	public static boolean validateFamily(EN en, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ENFamily", "ERROR");
-
-		if (VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EN);
-				try {
-					VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EN);
+			try {
+				VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(en)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_FAMILY__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(en)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -223,7 +205,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -236,23 +218,17 @@
 	 * @generated
 	 */
 	public static boolean validateGiven(EN en, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ENGiven", "ERROR");
-
-		if (VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EN);
-				try {
-					VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EN);
+			try {
+				VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(en)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_GIVEN__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(en)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -287,7 +263,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -300,23 +276,17 @@
 	 * @generated
 	 */
 	public static boolean validatePrefix(EN en, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ENPrefix", "ERROR");
-
-		if (VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EN);
-				try {
-					VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EN);
+			try {
+				VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(en)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_PREFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(en)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -351,7 +321,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -364,23 +334,17 @@
 	 * @generated
 	 */
 	public static boolean validateSuffix(EN en, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ENSuffix", "ERROR");
-
-		if (VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.EN);
-				try {
-					VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.EN);
+			try {
+				VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(en)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_SUFFIX__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(en)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IIOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IIOperations.java
index 2d6d340..b3db773 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IIOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IIOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.II;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +86,17 @@
 	 * @generated
 	 */
 	public static boolean validateII(II ii, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IIII", "ERROR");
-
-		if (VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.II);
-				try {
-					VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.II);
+			try {
+				VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(ii)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_II__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ii)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/INTOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/INTOperations.java
index 60b4c5c..449af62 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/INTOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/INTOperations.java
@@ -18,7 +18,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.INT;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -47,12 +46,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -81,7 +75,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -94,23 +88,17 @@
 	 * @generated
 	 */
 	public static boolean validateINT(INT int_, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "INTINT", "ERROR");
-
-		if (VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.INT);
-				try {
-					VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.INT);
+			try {
+				VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(int_)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(int_)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_INTOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_INTOperations.java
index d51348f..789ba5e 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_INTOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_INTOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.IVL_INT;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -43,20 +42,6 @@
  */
 public class IVL_INTOperations extends INTOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -83,7 +68,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -97,24 +82,17 @@
 	 */
 	public static boolean validateOptionsContainingLow(IVL_INT ivL_INT, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_INTOptionsContainingLow", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_INT);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_INT);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_INT)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_INT)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -150,7 +128,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -164,24 +142,17 @@
 	 */
 	public static boolean validateOptionsContainingCenter(IVL_INT ivL_INT, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_INTOptionsContainingCenter", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_INT);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_INT);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_INT)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_INT)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -217,7 +188,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -231,24 +202,17 @@
 	 */
 	public static boolean validateOptionsContainingHigh(IVL_INT ivL_INT, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_INTOptionsContainingHigh", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_INT);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_INT);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_INT)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_INT)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -284,7 +248,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -298,24 +262,17 @@
 	 */
 	public static boolean validateOptionsContainingWidth(IVL_INT ivL_INT, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_INTOptionsContainingWidth", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_INT);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_INT);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_INT)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_INT)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_PQOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_PQOperations.java
index 117f558..93c64f3 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_PQOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_PQOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.IVL_PQ;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -48,12 +47,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -82,7 +76,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -96,24 +90,17 @@
 	 */
 	public static boolean validateOptionsContainingLow(IVL_PQ ivL_PQ, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_PQOptionsContainingLow", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_PQ);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_PQ);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_PQ)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_PQ)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -149,7 +136,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -163,24 +150,17 @@
 	 */
 	public static boolean validateOptionsContainingCenter(IVL_PQ ivL_PQ, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_PQOptionsContainingCenter", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_PQ);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_PQ);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_PQ)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_PQ)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -216,7 +196,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -230,24 +210,17 @@
 	 */
 	public static boolean validateOptionsContainingHigh(IVL_PQ ivL_PQ, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_PQOptionsContainingHigh", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_PQ);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_PQ);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_PQ)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_PQ)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -283,7 +256,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -297,24 +270,17 @@
 	 */
 	public static boolean validateOptionsContainingWidth(IVL_PQ ivL_PQ, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_PQOptionsContainingWidth", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_PQ);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_PQ);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_PQ)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_PQ)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_REALOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_REALOperations.java
new file mode 100644
index 0000000..73f360c
--- /dev/null
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_REALOperations.java
@@ -0,0 +1,288 @@
+/**
+ */
+package org.eclipse.mdht.uml.hl7.datatypes.operations;
+
+import java.util.Map;
+
+import org.eclipse.emf.common.util.BasicDiagnostic;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.DiagnosticChain;
+
+import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
+import org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL;
+
+import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
+
+import org.eclipse.ocl.ParserException;
+
+import org.eclipse.ocl.ecore.Constraint;
+import org.eclipse.ocl.ecore.OCL;
+
+/**
+ * <!-- begin-user-doc -->
+ * A static utility class that provides operations related to '<em><b>IVL REAL</b></em>' model objects.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following operations are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#validateOptionsContainingLow(org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Low</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#validateOptionsContainingCenter(org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Center</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#validateOptionsContainingHigh(org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing High</em>}</li>
+ *   <li>{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL#validateOptionsContainingWidth(org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Width</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IVL_REALOperations extends REALOperations {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IVL_REALOperations() {
+		super();
+	}
+
+	/**
+	 * The cached OCL expression body for the '{@link #validateOptionsContainingLow(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Low</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingLow(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP = "not self.low.oclIsUndefined() implies self.center.oclIsUndefined() and (self.width.oclIsUndefined() or self.high.oclIsUndefined())";
+
+	/**
+	 * The cached OCL invariant for the '{@link #validateOptionsContainingLow(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Low</em>}' invariant operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingLow(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param ivL_REAL The receiving '<em><b>IVL REAL</b></em>' model object.
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @generated
+	 */
+	public static boolean validateOptionsContainingLow(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_REAL);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
+			}
+		}
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_REAL)) {
+			if (diagnostics != null) {
+				diagnostics.add(
+					new BasicDiagnostic(
+						Diagnostic.ERROR, DatatypesValidator.DIAGNOSTIC_SOURCE,
+						DatatypesValidator.IVL_REAL__OPTIONS_CONTAINING_LOW,
+						org.eclipse.emf.ecore.plugin.EcorePlugin.INSTANCE.getString(
+							"_UI_GenericInvariant_diagnostic",
+							new Object[] {
+									"validateOptionsContainingLow",
+									org.eclipse.emf.ecore.util.EObjectValidator.getObjectLabel(ivL_REAL, context) }),
+						new Object[] { ivL_REAL }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * The cached OCL expression body for the '{@link #validateOptionsContainingCenter(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Center</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingCenter(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP = "not self.center.oclIsUndefined() implies self.high.oclIsUndefined() and self.low.oclIsUndefined()";
+
+	/**
+	 * The cached OCL invariant for the '{@link #validateOptionsContainingCenter(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Center</em>}' invariant operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingCenter(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param ivL_REAL The receiving '<em><b>IVL REAL</b></em>' model object.
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @generated
+	 */
+	public static boolean validateOptionsContainingCenter(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_REAL);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
+			}
+		}
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_REAL)) {
+			if (diagnostics != null) {
+				diagnostics.add(
+					new BasicDiagnostic(
+						Diagnostic.ERROR, DatatypesValidator.DIAGNOSTIC_SOURCE,
+						DatatypesValidator.IVL_REAL__OPTIONS_CONTAINING_CENTER,
+						org.eclipse.emf.ecore.plugin.EcorePlugin.INSTANCE.getString(
+							"_UI_GenericInvariant_diagnostic",
+							new Object[] {
+									"validateOptionsContainingCenter",
+									org.eclipse.emf.ecore.util.EObjectValidator.getObjectLabel(ivL_REAL, context) }),
+						new Object[] { ivL_REAL }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * The cached OCL expression body for the '{@link #validateOptionsContainingHigh(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing High</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingHigh(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP = "not self.high.oclIsUndefined() implies (self.low.oclIsUndefined() and self.center.oclIsUndefined() and self.width.oclIsUndefined()) or ((not self.low.oclIsUndefined()) and self.width.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.width.oclIsUndefined()) and self.low.oclIsUndefined() and self.center.oclIsUndefined())";
+
+	/**
+	 * The cached OCL invariant for the '{@link #validateOptionsContainingHigh(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing High</em>}' invariant operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingHigh(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param ivL_REAL The receiving '<em><b>IVL REAL</b></em>' model object.
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @generated
+	 */
+	public static boolean validateOptionsContainingHigh(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_REAL);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
+			}
+		}
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_REAL)) {
+			if (diagnostics != null) {
+				diagnostics.add(
+					new BasicDiagnostic(
+						Diagnostic.ERROR, DatatypesValidator.DIAGNOSTIC_SOURCE,
+						DatatypesValidator.IVL_REAL__OPTIONS_CONTAINING_HIGH,
+						org.eclipse.emf.ecore.plugin.EcorePlugin.INSTANCE.getString(
+							"_UI_GenericInvariant_diagnostic",
+							new Object[] {
+									"validateOptionsContainingHigh",
+									org.eclipse.emf.ecore.util.EObjectValidator.getObjectLabel(ivL_REAL, context) }),
+						new Object[] { ivL_REAL }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * The cached OCL expression body for the '{@link #validateOptionsContainingWidth(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Width</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingWidth(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP = "not self.width.oclIsUndefined() implies ((not self.low.oclIsUndefined()) and self.center.oclIsUndefined() and self.high.oclIsUndefined()) or (self.low.oclIsUndefined() and self.center.oclIsUndefined()) or ((not self.center.oclIsUndefined()) and self.low.oclIsUndefined() and self.high.oclIsUndefined())";
+
+	/**
+	 * The cached OCL invariant for the '{@link #validateOptionsContainingWidth(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Options Containing Width</em>}' invariant operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #validateOptionsContainingWidth(IVL_REAL, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map)
+	 * @generated
+	 * @ordered
+	 */
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * @param ivL_REAL The receiving '<em><b>IVL REAL</b></em>' model object.
+	 * @param diagnostics The chain of diagnostics to which problems are to be appended.
+	 * @param context The cache of context-specific information.
+	 * <!-- end-model-doc -->
+	 * @generated
+	 */
+	public static boolean validateOptionsContainingWidth(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_REAL);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
+			}
+		}
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_REAL)) {
+			if (diagnostics != null) {
+				diagnostics.add(
+					new BasicDiagnostic(
+						Diagnostic.ERROR, DatatypesValidator.DIAGNOSTIC_SOURCE,
+						DatatypesValidator.IVL_REAL__OPTIONS_CONTAINING_WIDTH,
+						org.eclipse.emf.ecore.plugin.EcorePlugin.INSTANCE.getString(
+							"_UI_GenericInvariant_diagnostic",
+							new Object[] {
+									"validateOptionsContainingWidth",
+									org.eclipse.emf.ecore.util.EObjectValidator.getObjectLabel(ivL_REAL, context) }),
+						new Object[] { ivL_REAL }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+} // IVL_REALOperations
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_TSOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_TSOperations.java
index a25784f..b18559b 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_TSOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/IVL_TSOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.IVL_TS;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -48,12 +47,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -82,7 +76,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -96,24 +90,17 @@
 	 */
 	public static boolean validateOptionsContainingLow(IVL_TS ivL_TS, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_TSOptionsContainingLow", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_TS);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_TS);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_TS)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_LOW__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_TS)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -149,7 +136,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -163,24 +150,17 @@
 	 */
 	public static boolean validateOptionsContainingCenter(IVL_TS ivL_TS, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_TSOptionsContainingCenter", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_TS);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_TS);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_TS)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_CENTER__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_TS)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -216,7 +196,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -230,24 +210,17 @@
 	 */
 	public static boolean validateOptionsContainingHigh(IVL_TS ivL_TS, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_TSOptionsContainingHigh", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_TS);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_TS);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_TS)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_HIGH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_TS)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -283,7 +256,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -297,24 +270,17 @@
 	 */
 	public static boolean validateOptionsContainingWidth(IVL_TS ivL_TS, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "IVL_TSOptionsContainingWidth", "ERROR");
-
-		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.IVL_TS);
-				try {
-					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.IVL_TS);
+			try {
+				VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			ivL_TS)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_OPTIONS_CONTAINING_WIDTH__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(ivL_TS)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/MOOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/MOOperations.java
index 7a5569a..f488ba9 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/MOOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/MOOperations.java
@@ -18,7 +18,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.MO;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -47,12 +46,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -81,7 +75,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -94,23 +88,17 @@
 	 * @generated
 	 */
 	public static boolean validateMO(MO mo, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "MOMO", "ERROR");
-
-		if (VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.MO);
-				try {
-					VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.MO);
+			try {
+				VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(mo)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_MO__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(mo)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ONOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ONOperations.java
index 3a893e3..3bd1da8 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ONOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/ONOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.ON;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -39,20 +38,6 @@
  */
 public class ONOperations extends ENOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -79,7 +64,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +77,17 @@
 	 * @generated
 	 */
 	public static boolean validateInvariant(ON on, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "ONInvariant", "ERROR");
-
-		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ON);
-				try {
-					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ON);
+			try {
+				VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(on)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(on)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PNOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PNOperations.java
index 58d776b..00c0fdf 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PNOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PNOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.PN;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -39,20 +38,6 @@
  */
 public class PNOperations extends ENOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -79,7 +64,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +77,17 @@
 	 * @generated
 	 */
 	public static boolean validateInvariant(PN pn, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "PNInvariant", "ERROR");
-
-		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.PN);
-				try {
-					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.PN);
+			try {
+				VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(pn)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(pn)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQOperations.java
index 5f53769..e18772b 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQOperations.java
@@ -13,7 +13,6 @@
 import java.math.BigDecimal;
 
 import org.eclipse.mdht.uml.hl7.datatypes.PQ;
-import org.eclipse.ocl.ecore.OCL;
 
 /**
  * <!-- begin-user-doc -->
@@ -31,20 +30,6 @@
  */
 public class PQOperations extends ANYOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQROperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQROperations.java
index 247a009..1aa6d86 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQROperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/PQROperations.java
@@ -13,7 +13,6 @@
 import java.math.BigDecimal;
 
 import org.eclipse.mdht.uml.hl7.datatypes.PQR;
-import org.eclipse.ocl.ecore.OCL;
 
 /**
  * <!-- begin-user-doc -->
@@ -31,20 +30,6 @@
  */
 public class PQROperations extends CVOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/REALOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/REALOperations.java
index 4f795fa..8968b7c 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/REALOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/REALOperations.java
@@ -18,7 +18,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.REAL;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -47,12 +46,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -81,7 +75,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -94,23 +88,17 @@
 	 * @generated
 	 */
 	public static boolean validateREAL(REAL real, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "REALREAL", "ERROR");
-
-		if (VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.REAL);
-				try {
-					VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.REAL);
+			try {
+				VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(real)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_REAL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(real)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_PQ_PQOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_PQ_PQOperations.java
index ce85a56..6bfe8f3 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_PQ_PQOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_PQ_PQOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.RTO_PQ_PQ;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -93,23 +87,17 @@
 	 */
 	public static boolean validateDenominator(RTO_PQ_PQ rtO_PQ_PQ, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "RTO_PQ_PQDenominator", "ERROR");
-
-		if (VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.RTO_PQ_PQ);
-				try {
-					VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.RTO_PQ_PQ);
+			try {
+				VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(rtO_PQ_PQ)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(rtO_PQ_PQ)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_QTY_QTYOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_QTY_QTYOperations.java
index fe80d3e..ea555a2 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_QTY_QTYOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/RTO_QTY_QTYOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.RTO_QTY_QTY;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -93,24 +87,17 @@
 	 */
 	public static boolean validateDenominator(RTO_QTY_QTY rtO_QTY_QTY, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "RTO_QTY_QTYDenominator", "ERROR");
-
-		if (VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.RTO_QTY_QTY);
-				try {
-					VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.RTO_QTY_QTY);
+			try {
+				VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			rtO_QTY_QTY)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_DENOMINATOR__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(rtO_QTY_QTY)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/STOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/STOperations.java
index 7d1d24e..30bf8ca 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/STOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/STOperations.java
@@ -18,7 +18,6 @@
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.ST;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -50,20 +49,6 @@
  */
 public class STOperations extends EDOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -90,7 +75,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -103,23 +88,17 @@
 	 * @generated
 	 */
 	public static boolean validateThumbnail(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STThumbnail", "ERROR");
-
-		if (VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_THUMBNAIL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -154,7 +133,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -167,23 +146,17 @@
 	 * @generated
 	 */
 	public static boolean validateReference(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STReference", "ERROR");
-
-		if (VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_REFERENCE__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -218,7 +191,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -231,23 +204,17 @@
 	 * @generated
 	 */
 	public static boolean validateIntegrityCheck(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STIntegrityCheck", "ERROR");
-
-		if (VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INTEGRITY_CHECK__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -282,7 +249,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * The cached OCL expression body for the '{@link #validateCompression(ST, org.eclipse.emf.common.util.DiagnosticChain, java.util.Map) <em>Validate Compression</em>}' operation.
@@ -302,7 +269,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -315,23 +282,17 @@
 	 * @generated
 	 */
 	public static boolean validateCompression(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STCompression", "ERROR");
-
-		if (VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_COMPRESSION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -366,7 +327,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -379,23 +340,17 @@
 	 * @generated
 	 */
 	public static boolean validateRepresentation(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STRepresentation", "ERROR");
-
-		if (VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_REPRESENTATION__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -430,7 +385,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -443,23 +398,17 @@
 	 * @generated
 	 */
 	public static boolean validateST(ST st, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STST", "ERROR");
-
-		if (VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_ST__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
@@ -494,7 +443,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<OCLExpression<EClassifier>> IS_COMPRESSION_DEFINED__EOCL_QRY = new ThreadLocal<OCLExpression<EClassifier>>();
+	protected static OCLExpression<EClassifier> IS_COMPRESSION_DEFINED__EOCL_QRY;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -502,20 +451,17 @@
 	 * @generated
 	 */
 	public static boolean isCompressionDefined(ST st) {
-
-		if (IS_COMPRESSION_DEFINED__EOCL_QRY.get() == null) {
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setOperationContext(
-					DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(18));
-				try {
-					IS_COMPRESSION_DEFINED__EOCL_QRY.set(helper.createQuery(IS_COMPRESSION_DEFINED__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (IS_COMPRESSION_DEFINED__EOCL_QRY == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setOperationContext(
+				DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(18));
+			try {
+				IS_COMPRESSION_DEFINED__EOCL_QRY = helper.createQuery(IS_COMPRESSION_DEFINED__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		OCL.Query query = EOCL_ENV.get().createQuery(IS_COMPRESSION_DEFINED__EOCL_QRY.get());
+		OCL.Query query = EOCL_ENV.createQuery(IS_COMPRESSION_DEFINED__EOCL_QRY);
 		return ((Boolean) query.evaluate(st)).booleanValue();
 	}
 
@@ -537,7 +483,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<OCLExpression<EClassifier>> IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY = new ThreadLocal<OCLExpression<EClassifier>>();
+	protected static OCLExpression<EClassifier> IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -545,21 +491,18 @@
 	 * @generated
 	 */
 	public static boolean isIntegrityCheckAlgorithmDefined(ST st) {
-
-		if (IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY.get() == null) {
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setOperationContext(
-					DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(19));
-				try {
-					IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY.set(
-						helper.createQuery(IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setOperationContext(
+				DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(19));
+			try {
+				IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY = helper.createQuery(
+					IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		OCL.Query query = EOCL_ENV.get().createQuery(IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY.get());
+		OCL.Query query = EOCL_ENV.createQuery(IS_INTEGRITY_CHECK_ALGORITHM_DEFINED__EOCL_QRY);
 		return ((Boolean) query.evaluate(st)).booleanValue();
 	}
 
@@ -581,7 +524,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<OCLExpression<EClassifier>> IS_REPRESENTATION_DEFINED__EOCL_QRY = new ThreadLocal<OCLExpression<EClassifier>>();
+	protected static OCLExpression<EClassifier> IS_REPRESENTATION_DEFINED__EOCL_QRY;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -589,20 +532,17 @@
 	 * @generated
 	 */
 	public static boolean isRepresentationDefined(ST st) {
-
-		if (IS_REPRESENTATION_DEFINED__EOCL_QRY.get() == null) {
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setOperationContext(
-					DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(20));
-				try {
-					IS_REPRESENTATION_DEFINED__EOCL_QRY.set(helper.createQuery(IS_REPRESENTATION_DEFINED__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (IS_REPRESENTATION_DEFINED__EOCL_QRY == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setOperationContext(
+				DatatypesPackage.Literals.ST, DatatypesPackage.Literals.ST.getEAllOperations().get(20));
+			try {
+				IS_REPRESENTATION_DEFINED__EOCL_QRY = helper.createQuery(IS_REPRESENTATION_DEFINED__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		OCL.Query query = EOCL_ENV.get().createQuery(IS_REPRESENTATION_DEFINED__EOCL_QRY.get());
+		OCL.Query query = EOCL_ENV.createQuery(IS_REPRESENTATION_DEFINED__EOCL_QRY);
 		return ((Boolean) query.evaluate(st)).booleanValue();
 	}
 
@@ -618,24 +558,17 @@
 	 */
 	public static boolean validateIntegrityCheckAlgorithm(ST st, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "STIntegrityCheckAlgorithm", "ERROR");
-
-		if (VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.ST);
-				try {
-					VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.ST);
+			try {
+				VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(
-			st)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INTEGRITY_CHECK_ALGORITHM__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(st)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TELOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TELOperations.java
index cf2b34e..49d5878 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TELOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TELOperations.java
@@ -5,7 +5,6 @@
 import org.eclipse.emf.ecore.util.FeatureMap;
 import org.eclipse.emf.ecore.util.FeatureMapUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.TEL;
-import org.eclipse.ocl.ecore.OCL;
 
 /**
  * <!-- begin-user-doc -->
@@ -23,20 +22,6 @@
  */
 public class TELOperations extends URLOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TNOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TNOperations.java
index ff6d0fc..60f22ce 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TNOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/TNOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.TN;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -39,20 +38,6 @@
  */
 public class TNOperations extends ENOperations {
 	/**
-	 * The cached environment for evaluating OCL expressions.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
-
-	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -79,7 +64,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +77,17 @@
 	 * @generated
 	 */
 	public static boolean validateInvariant(TN tn, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "TNInvariant", "ERROR");
-
-		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.TN);
-				try {
-					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.TN);
+			try {
+				VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(tn)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_INVARIANT__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(tn)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/URLOperations.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/URLOperations.java
index 768c4e4..93b83f0 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/URLOperations.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/operations/URLOperations.java
@@ -17,7 +17,6 @@
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.mdht.uml.hl7.datatypes.DatatypesPackage;
 import org.eclipse.mdht.uml.hl7.datatypes.URL;
-import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesUtil;
 import org.eclipse.mdht.uml.hl7.datatypes.util.DatatypesValidator;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.ecore.Constraint;
@@ -45,12 +44,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static final ThreadLocal<OCL> EOCL_ENV = new ThreadLocal<OCL>() {
-		@Override
-		public OCL initialValue() {
-			return OCL.newInstance();
-		}
-	};
+	protected static final OCL EOCL_ENV = OCL.newInstance();
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -79,7 +73,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	protected static ThreadLocal<Constraint> VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = new ThreadLocal<Constraint>();
+	protected static Constraint VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV;
 
 	/**
 	 * <!-- begin-user-doc -->
@@ -92,23 +86,17 @@
 	 * @generated
 	 */
 	public static boolean validateURL(URL url, DiagnosticChain diagnostics, Map<Object, Object> context) {
-
-		DatatypesUtil.increment(context, "URLURL", "ERROR");
-
-		if (VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get() == null) {
-
-			synchronized (EOCL_ENV) {
-				OCL.Helper helper = EOCL_ENV.get().createOCLHelper();
-				helper.setContext(DatatypesPackage.Literals.URL);
-				try {
-					VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.set(
-						helper.createInvariant(VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP));
-				} catch (ParserException pe) {
-					throw new UnsupportedOperationException(pe.getLocalizedMessage());
-				}
+		if (VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV == null) {
+			OCL.Helper helper = EOCL_ENV.createOCLHelper();
+			helper.setContext(DatatypesPackage.Literals.URL);
+			try {
+				VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV = helper.createInvariant(
+					VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_EXP);
+			} catch (ParserException pe) {
+				throw new UnsupportedOperationException(pe.getLocalizedMessage());
 			}
 		}
-		if (!EOCL_ENV.get().createQuery(VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV.get()).check(url)) {
+		if (!EOCL_ENV.createQuery(VALIDATE_URL__DIAGNOSTIC_CHAIN_MAP__EOCL_INV).check(url)) {
 			if (diagnostics != null) {
 				diagnostics.add(
 					new BasicDiagnostic(
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesAdapterFactory.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesAdapterFactory.java
index 8129495..11ab043 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesAdapterFactory.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesAdapterFactory.java
@@ -14,6 +14,7 @@
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.mdht.uml.hl7.datatypes.*;
 import org.eclipse.mdht.uml.hl7.datatypes.AD;
 import org.eclipse.mdht.uml.hl7.datatypes.ADXP;
 import org.eclipse.mdht.uml.hl7.datatypes.ANY;
@@ -342,6 +343,21 @@
 		}
 
 		@Override
+		public Adapter caseSXCM_REAL(SXCM_REAL object) {
+			return createSXCM_REALAdapter();
+		}
+
+		@Override
+		public Adapter caseIVXB_REAL(IVXB_REAL object) {
+			return createIVXB_REALAdapter();
+		}
+
+		@Override
+		public Adapter caseIVL_REAL(IVL_REAL object) {
+			return createIVL_REALAdapter();
+		}
+
+		@Override
 		public Adapter defaultCase(EObject object) {
 			return createEObjectAdapter();
 		}
@@ -991,6 +1007,48 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL <em>SXCM REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.SXCM_REAL
+	 * @generated
+	 */
+	public Adapter createSXCM_REALAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL <em>IVXB REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVXB_REAL
+	 * @generated
+	 */
+	public Adapter createIVXB_REALAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL <em>IVL REAL</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.mdht.uml.hl7.datatypes.IVL_REAL
+	 * @generated
+	 */
+	public Adapter createIVL_REALAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for the default case.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null.
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesSwitch.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesSwitch.java
index 9c52ca3..f93c092 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesSwitch.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesSwitch.java
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.mdht.uml.hl7.datatypes.*;
 import org.eclipse.mdht.uml.hl7.datatypes.AD;
 import org.eclipse.mdht.uml.hl7.datatypes.ADXP;
 import org.eclipse.mdht.uml.hl7.datatypes.ANY;
@@ -810,6 +811,60 @@
 				}
 				return result;
 			}
+			case DatatypesPackage.SXCM_REAL: {
+				SXCM_REAL sxcM_REAL = (SXCM_REAL) theEObject;
+				T result = caseSXCM_REAL(sxcM_REAL);
+				if (result == null) {
+					result = caseREAL(sxcM_REAL);
+				}
+				if (result == null) {
+					result = caseQTY(sxcM_REAL);
+				}
+				if (result == null) {
+					result = caseANY(sxcM_REAL);
+				}
+				if (result == null) {
+					result = defaultCase(theEObject);
+				}
+				return result;
+			}
+			case DatatypesPackage.IVXB_REAL: {
+				IVXB_REAL ivxB_REAL = (IVXB_REAL) theEObject;
+				T result = caseIVXB_REAL(ivxB_REAL);
+				if (result == null) {
+					result = caseREAL(ivxB_REAL);
+				}
+				if (result == null) {
+					result = caseQTY(ivxB_REAL);
+				}
+				if (result == null) {
+					result = caseANY(ivxB_REAL);
+				}
+				if (result == null) {
+					result = defaultCase(theEObject);
+				}
+				return result;
+			}
+			case DatatypesPackage.IVL_REAL: {
+				IVL_REAL ivL_REAL = (IVL_REAL) theEObject;
+				T result = caseIVL_REAL(ivL_REAL);
+				if (result == null) {
+					result = caseSXCM_REAL(ivL_REAL);
+				}
+				if (result == null) {
+					result = caseREAL(ivL_REAL);
+				}
+				if (result == null) {
+					result = caseQTY(ivL_REAL);
+				}
+				if (result == null) {
+					result = caseANY(ivL_REAL);
+				}
+				if (result == null) {
+					result = defaultCase(theEObject);
+				}
+				return result;
+			}
 			default:
 				return defaultCase(theEObject);
 		}
@@ -1491,6 +1546,51 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>SXCM REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>SXCM REAL</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseSXCM_REAL(SXCM_REAL object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>IVXB REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>IVXB REAL</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseIVXB_REAL(IVXB_REAL object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>IVL REAL</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseIVL_REAL(IVL_REAL object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
diff --git a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesValidator.java b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesValidator.java
index c13d0ee..4ee2da9 100644
--- a/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesValidator.java
+++ b/cda/plugins/org.eclipse.mdht.uml.hl7.datatypes/src/org/eclipse/mdht/uml/hl7/datatypes/util/DatatypesValidator.java
@@ -18,6 +18,7 @@
 import org.eclipse.emf.ecore.util.EObjectValidator;
 import org.eclipse.emf.ecore.xml.type.util.XMLTypeUtil;
 import org.eclipse.emf.ecore.xml.type.util.XMLTypeValidator;
+import org.eclipse.mdht.uml.hl7.datatypes.*;
 import org.eclipse.mdht.uml.hl7.datatypes.AD;
 import org.eclipse.mdht.uml.hl7.datatypes.ADXP;
 import org.eclipse.mdht.uml.hl7.datatypes.ANY;
@@ -718,12 +719,44 @@
 	public static final int EIVL_EVENT__CODE = 78;
 
 	/**
+	 * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate Options Containing Low' of 'IVL REAL'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final int IVL_REAL__OPTIONS_CONTAINING_LOW = 79;
+
+	/**
+	 * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate Options Containing Center' of 'IVL REAL'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final int IVL_REAL__OPTIONS_CONTAINING_CENTER = 80;
+
+	/**
+	 * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate Options Containing High' of 'IVL REAL'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final int IVL_REAL__OPTIONS_CONTAINING_HIGH = 81;
+
+	/**
+	 * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate Options Containing Width' of 'IVL REAL'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final int IVL_REAL__OPTIONS_CONTAINING_WIDTH = 82;
+
+	/**
 	 * A constant with a fixed name that can be used as the base value for additional hand written constants.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	private static final int GENERATED_DIAGNOSTIC_CODE_COUNT = 78;
+	private static final int GENERATED_DIAGNOSTIC_CODE_COUNT = 82;
 
 	/**
 	 * A constant with a fixed name that can be used as the base value for additional hand written constants in a derived class.
@@ -863,6 +896,12 @@
 				return validateEIVL_event((EIVL_event) value, diagnostics, context);
 			case DatatypesPackage.EIVL_TS:
 				return validateEIVL_TS((EIVL_TS) value, diagnostics, context);
+			case DatatypesPackage.SXCM_REAL:
+				return validateSXCM_REAL((SXCM_REAL) value, diagnostics, context);
+			case DatatypesPackage.IVXB_REAL:
+				return validateIVXB_REAL((IVXB_REAL) value, diagnostics, context);
+			case DatatypesPackage.IVL_REAL:
+				return validateIVL_REAL((IVL_REAL) value, diagnostics, context);
 			case DatatypesPackage.BINARY_DATA_ENCODING:
 				return validateBinaryDataEncoding((BinaryDataEncoding) value, diagnostics, context);
 			case DatatypesPackage.TS_TYPE:
@@ -3319,6 +3358,173 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public boolean validateSXCM_REAL(SXCM_REAL sxcM_REAL, DiagnosticChain diagnostics, Map<Object, Object> context) {
+		if (!validate_NoCircularContainment(sxcM_REAL, diagnostics, context)) {
+			return false;
+		}
+		boolean result = validate_EveryMultiplicityConforms(sxcM_REAL, diagnostics, context);
+		if (result || diagnostics != null) {
+			result &= validate_EveryDataValueConforms(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryReferenceIsContained(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryBidirectionalReferenceIsPaired(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryProxyResolves(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_UniqueID(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryKeyUnique(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryMapEntryUnique(sxcM_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateREAL_validateREAL(sxcM_REAL, diagnostics, context);
+		}
+		return result;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVXB_REAL(IVXB_REAL ivxB_REAL, DiagnosticChain diagnostics, Map<Object, Object> context) {
+		if (!validate_NoCircularContainment(ivxB_REAL, diagnostics, context)) {
+			return false;
+		}
+		boolean result = validate_EveryMultiplicityConforms(ivxB_REAL, diagnostics, context);
+		if (result || diagnostics != null) {
+			result &= validate_EveryDataValueConforms(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryReferenceIsContained(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryBidirectionalReferenceIsPaired(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryProxyResolves(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_UniqueID(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryKeyUnique(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryMapEntryUnique(ivxB_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateREAL_validateREAL(ivxB_REAL, diagnostics, context);
+		}
+		return result;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVL_REAL(IVL_REAL ivL_REAL, DiagnosticChain diagnostics, Map<Object, Object> context) {
+		if (!validate_NoCircularContainment(ivL_REAL, diagnostics, context)) {
+			return false;
+		}
+		boolean result = validate_EveryMultiplicityConforms(ivL_REAL, diagnostics, context);
+		if (result || diagnostics != null) {
+			result &= validate_EveryDataValueConforms(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryReferenceIsContained(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryBidirectionalReferenceIsPaired(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryProxyResolves(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_UniqueID(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryKeyUnique(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validate_EveryMapEntryUnique(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateREAL_validateREAL(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateIVL_REAL_validateOptionsContainingLow(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateIVL_REAL_validateOptionsContainingCenter(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateIVL_REAL_validateOptionsContainingHigh(ivL_REAL, diagnostics, context);
+		}
+		if (result || diagnostics != null) {
+			result &= validateIVL_REAL_validateOptionsContainingWidth(ivL_REAL, diagnostics, context);
+		}
+		return result;
+	}
+
+	/**
+	 * Validates the validateOptionsContainingLow constraint of '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVL_REAL_validateOptionsContainingLow(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		return ivL_REAL.validateOptionsContainingLow(diagnostics, context);
+	}
+
+	/**
+	 * Validates the validateOptionsContainingCenter constraint of '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVL_REAL_validateOptionsContainingCenter(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		return ivL_REAL.validateOptionsContainingCenter(diagnostics, context);
+	}
+
+	/**
+	 * Validates the validateOptionsContainingHigh constraint of '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVL_REAL_validateOptionsContainingHigh(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		return ivL_REAL.validateOptionsContainingHigh(diagnostics, context);
+	}
+
+	/**
+	 * Validates the validateOptionsContainingWidth constraint of '<em>IVL REAL</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean validateIVL_REAL_validateOptionsContainingWidth(IVL_REAL ivL_REAL, DiagnosticChain diagnostics,
+			Map<Object, Object> context) {
+		return ivL_REAL.validateOptionsContainingWidth(diagnostics, context);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public boolean validateBinaryDataEncoding(BinaryDataEncoding binaryDataEncoding, DiagnosticChain diagnostics,
 			Map<Object, Object> context) {
 		return true;
