Initializes the annotations for <b>http:///org/eclipse/emf/ecore/util/ExtendedMetaData</b>.
<!-- begin-user-doc -->
<!-- end-user-doc -->
@generated
555132
protected void createExtendedMetaDataAnnotations() {
		String source = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";		
		addAnnotation
		  (betaDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BetaDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBetaDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getBetaDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });		
		addAnnotation
		  (binomialDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BinomialDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBinomialDistributionType_Probability(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "probability"
		   });		
		addAnnotation
		  (getBinomialDistributionType_Trials(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "trials"
		   });		
		addAnnotation
		  (booleanParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BooleanParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBooleanParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (bpSimDataTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BPSimData_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getBPSimDataType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:0"
		   });		
		addAnnotation
		  (getBPSimDataType_Scenario(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Scenario",
			 "namespace", "##targetNamespace",
			 "group", "#group:0"
		   });		
		addAnnotation
		  (calendarEClass, 
		   source, 
		   new String[] {
			 "name", "Calendar",
			 "kind", "simple"
		   });		
		addAnnotation
		  (getCalendar_Value(), 
		   source, 
		   new String[] {
			 "name", ":0",
			 "kind", "simple"
		   });		
		addAnnotation
		  (getCalendar_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (getCalendar_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (constantParameterEClass, 
		   source, 
		   new String[] {
			 "name", "ConstantParameter",
			 "kind", "empty"
		   });		
		addAnnotation
		  (controlParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ControlParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getControlParameters_Probability(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Probability",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_Condition(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Condition",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_InterTriggerTimer(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "InterTriggerTimer",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_TriggerCount(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TriggerCount",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (costParametersEClass, 
		   source, 
		   new String[] {
			 "name", "CostParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getCostParameters_FixedCost(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "FixedCost",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getCostParameters_UnitCost(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UnitCost",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (dateTimeParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "DateTimeParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDateTimeParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (distributionParameterEClass, 
		   source, 
		   new String[] {
			 "name", "DistributionParameter",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDistributionParameter_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getDistributionParameter_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (documentRootEClass, 
		   source, 
		   new String[] {
			 "name", "",
			 "kind", "mixed"
		   });		
		addAnnotation
		  (getDocumentRoot_Mixed(), 
		   source, 
		   new String[] {
			 "kind", "elementWildcard",
			 "name", ":mixed"
		   });		
		addAnnotation
		  (getDocumentRoot_XMLNSPrefixMap(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "xmlns:prefix"
		   });		
		addAnnotation
		  (getDocumentRoot_XSISchemaLocation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "xsi:schemaLocation"
		   });		
		addAnnotation
		  (getDocumentRoot_BetaDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BetaDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_BinomialDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BinomialDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_BooleanParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BooleanParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_BPSimData(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BPSimData",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_DateTimeParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "DateTimeParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_DurationParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "DurationParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_EnumParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "EnumParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ErlangDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ErlangDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ExpressionParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ExpressionParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_FloatingParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "FloatingParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_GammaDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "GammaDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_LogNormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "LogNormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NegativeExponentialDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NegativeExponentialDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NumericParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NumericParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_PoissonDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PoissonDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_StringParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "StringParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_TriangularDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TriangularDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_TruncatedNormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TruncatedNormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UniformDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UniformDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UserDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UserDistributionDataPoint(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistributionDataPoint",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_WeibullDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "WeibullDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (durationParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "DurationParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDurationParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (elementParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ElementParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getElementParameters_TimeParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TimeParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ControlParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ControlParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ResourceParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ResourceParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_PriorityParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PriorityParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_CostParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "CostParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_PropertyParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PropertyParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_VendorExtension(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "VendorExtension",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ElementRef(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "elementRef"
		   });		
		addAnnotation
		  (getElementParameters_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (elementParametersTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ElementParametersType",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (enumParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "EnumParameter_._type",
			 "kind", "elementOnly"
		   });			
		addAnnotation
		  (getEnumParameterType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:3"
		   });		
		addAnnotation
		  (getEnumParameterType_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace",
			 "group", "#group:3"
		   });		
		addAnnotation
		  (getEnumParameterType_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (erlangDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ErlangDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getErlangDistributionType_K(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "k"
		   });		
		addAnnotation
		  (getErlangDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (expressionParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ExpressionParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getExpressionParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (floatingParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "FloatingParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getFloatingParameterType_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getFloatingParameterType_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (getFloatingParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (gammaDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "GammaDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getGammaDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getGammaDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });		
		addAnnotation
		  (logNormalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "LogNormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getLogNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getLogNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (negativeExponentialDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NegativeExponentialDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNegativeExponentialDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (normalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (numericParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NumericParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNumericParameterType_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getNumericParameterType_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (getNumericParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (parameterEClass, 
		   source, 
		   new String[] {
			 "name", "Parameter",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getParameter_ResultRequest(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ResultRequest",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getParameter_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getParameter_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (getParameter_Kpi(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "kpi"
		   });		
		addAnnotation
		  (getParameter_Sla(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "sla"
		   });		
		addAnnotation
		  (parameterValueEClass, 
		   source, 
		   new String[] {
			 "name", "ParameterValue",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getParameterValue_Instance(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "instance"
		   });		
		addAnnotation
		  (getParameterValue_Result(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "result"
		   });		
		addAnnotation
		  (getParameterValue_ValidFor(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "validFor"
		   });		
		addAnnotation
		  (poissonDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "PoissonDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getPoissonDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (priorityParametersEClass, 
		   source, 
		   new String[] {
			 "name", "PriorityParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPriorityParameters_Interruptible(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Interruptible",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getPriorityParameters_Priority(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Priority",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (propertyParametersEClass, 
		   source, 
		   new String[] {
			 "name", "PropertyParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPropertyParameters_Property(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Property",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (propertyTypeEClass, 
		   source, 
		   new String[] {
			 "name", "Property_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPropertyType_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (resourceParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ResourceParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getResourceParameters_Selection(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Selection",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Availability(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Availability",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Quantity(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Quantity",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Role(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Role",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (resultTypeEEnum, 
		   source, 
		   new String[] {
			 "name", "ResultType"
		   });		
		addAnnotation
		  (resultTypeObjectEDataType, 
		   source, 
		   new String[] {
			 "name", "ResultType:Object",
			 "baseType", "ResultType"
		   });		
		addAnnotation
		  (scenarioEClass, 
		   source, 
		   new String[] {
			 "name", "Scenario",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getScenario_ScenarioParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ScenarioParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_ElementParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ElementParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_Calendar(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Calendar",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_VendorExtension(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "VendorExtension",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_Author(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "author"
		   });		
		addAnnotation
		  (getScenario_Created(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "created"
		   });		
		addAnnotation
		  (getScenario_Description(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "description"
		   });		
		addAnnotation
		  (getScenario_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (getScenario_Inherits(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "inherits"
		   });		
		addAnnotation
		  (getScenario_Modified(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "modified"
		   });		
		addAnnotation
		  (getScenario_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (getScenario_Result(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "result"
		   });		
		addAnnotation
		  (getScenario_Vendor(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "vendor"
		   });		
		addAnnotation
		  (getScenario_Version(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "version"
		   });		
		addAnnotation
		  (scenarioParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ScenarioParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getScenarioParameters_Start(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Start",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_Duration(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Duration",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_PropertyParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PropertyParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_BaseCurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "baseCurrencyUnit"
		   });		
		addAnnotation
		  (getScenarioParameters_BaseTimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "baseTimeUnit"
		   });		
		addAnnotation
		  (getScenarioParameters_Replication(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "replication"
		   });		
		addAnnotation
		  (getScenarioParameters_Seed(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "seed"
		   });		
		addAnnotation
		  (scenarioParametersTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ScenarioParameters_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (stringParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "StringParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getStringParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (timeParametersEClass, 
		   source, 
		   new String[] {
			 "name", "TimeParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getTimeParameters_TransferTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TransferTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_QueueTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "QueueTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_WaitTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "WaitTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_SetUpTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "SetUpTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ProcessingTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ProcessingTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ValidationTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ValidationTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ReworkTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ReworkTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (timeUnitEEnum, 
		   source, 
		   new String[] {
			 "name", "TimeUnit"
		   });		
		addAnnotation
		  (timeUnitObjectEDataType, 
		   source, 
		   new String[] {
			 "name", "TimeUnit:Object",
			 "baseType", "TimeUnit"
		   });		
		addAnnotation
		  (triangularDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "TriangularDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Mode(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mode"
		   });		
		addAnnotation
		  (truncatedNormalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "TruncatedNormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (uniformDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UniformDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getUniformDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getUniformDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (userDistributionDataPointTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UserDistributionDataPoint_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_Probability(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "probability"
		   });		
		addAnnotation
		  (userDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UserDistribution_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getUserDistributionType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:5"
		   });		
		addAnnotation
		  (getUserDistributionType_UserDistributionDataPoint(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistributionDataPoint",
			 "namespace", "##targetNamespace",
			 "group", "#group:5"
		   });		
		addAnnotation
		  (getUserDistributionType_Discrete(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "discrete"
		   });		
		addAnnotation
		  (vendorExtensionEClass, 
		   source, 
		   new String[] {
			 "name", "VendorExtension",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getVendorExtension_Any(), 
		   source, 
		   new String[] {
			 "kind", "elementWildcard",
			 "wildcards", "##other",
			 "name", ":0",
			 "processing", "strict"
		   });		
		addAnnotation
		  (getVendorExtension_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (getVendorExtension_AnyAttribute(), 
		   source, 
		   new String[] {
			 "kind", "attributeWildcard",
			 "wildcards", "##other",
			 "name", ":2",
			 "processing", "strict"
		   });		
		addAnnotation
		  (weibullDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "WeibullDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getWeibullDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getWeibullDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });
	}
142083
public void init(Email annotation, PropertyMetadata propertyMetadata)
    {
        m_propertyMetadata = propertyMetadata;
        m_pattern = java.util.regex.Pattern.compile("^" + ATOM + "+(\\." + ATOM + "+)*@"
                + DOMAIN
                + "|"
                + IP_DOMAIN
                + ")$",
        java.util.regex.Pattern.CASE_INSENSITIVE
);
        m_message = annotation.message();
    }
43711
private void initStandardTaglets() {
        if (javafx) {
            initJavaFXTaglets();
        }

        Taglet temp;
        addStandardTaglet(new ParamTaglet());
        addStandardTaglet(new ReturnTaglet());
        addStandardTaglet(new ThrowsTaglet());
        addStandardTaglet(new SimpleTaglet("exception", null,
                SimpleTaglet.METHOD + SimpleTaglet.CONSTRUCTOR));
        addStandardTaglet(!nosince, new SimpleTaglet("since", message.getText("doclet.Since"),
               SimpleTaglet.ALL));
        addStandardTaglet(showversion, new SimpleTaglet("version", message.getText("doclet.Version"),
                SimpleTaglet.PACKAGE + SimpleTaglet.TYPE + SimpleTaglet.OVERVIEW));
        addStandardTaglet(showauthor, new SimpleTaglet("author", message.getText("doclet.Author"),
                SimpleTaglet.PACKAGE + SimpleTaglet.TYPE + SimpleTaglet.OVERVIEW));
        addStandardTaglet(new SimpleTaglet("serialData", message.getText("doclet.SerialData"),
            SimpleTaglet.EXCLUDED));
        customTags.put((temp = new SimpleTaglet("factory", message.getText("doclet.Factory"),
            SimpleTaglet.METHOD)).getName(), temp);
        addStandardTaglet(new SeeTaglet());
        //Standard inline tags
        addStandardTaglet(new DocRootTaglet());
        addStandardTaglet(new InheritDocTaglet());
        addStandardTaglet(new ValueTaglet());
        addStandardTaglet(new LiteralTaglet());
        addStandardTaglet(new CodeTaglet());
        addStandardTaglet(new IndexTaglet());

        // Keep track of the names of standard tags for error
        // checking purposes. The following are not handled above.
        // See, for example, com.sun.tools.javadoc.Comment
        standardTags.add("deprecated");
        standardTags.add("link");
        standardTags.add("linkplain");
        standardTags.add("serial");
        standardTags.add("serialField");
        standardTags.add("Text");
    }
303054
protected function setupAnnotationMetadata()
    {
        $annotationFiles = (array) $this->getOption('annotation_files');
        array_walk(
            $annotationFiles,
            function ($file) {
                if (!file_exists($file)) {
                    throw new \RuntimeException(sprintf('"%s" file does not exist', $file));
                }

                AnnotationRegistry::registerFile($file);
            }
        );

        AnnotationRegistry::registerAutoloadNamespaces($this->getAnnotationNamespaces());

        $annotationLoaders = (array) $this->getOption('annotation_autoloaders');
        array_walk(
            $annotationLoaders,
            function ($autoLoader) {
                AnnotationRegistry::registerLoader($autoLoader);
            }
        );
    }
1328904
private void init(){
	
		if(!Annotation.isInheritedMapped(configuredClass))
			Error.classNotMapped(configuredClass);
		
		for (Class<?> classe :getClasses()){
			relationalManyToOneMapper.put(classe.getName(), new JMapper(configuredClass, classe,ChooseConfig.DESTINATION));
			relationalOneToManyMapper.put(classe.getName(), new JMapper(classe, configuredClass,ChooseConfig.SOURCE));
		}
	}
1169837
private void initCustomTaglets() {

        moduleTags = new ArrayList<>();
        packageTags = new ArrayList<>();
        typeTags = new ArrayList<>();
        fieldTags = new ArrayList<>();
        constructorTags = new ArrayList<>();
        methodTags = new ArrayList<>();
        inlineTags = new ArrayList<>();
        overviewTags = new ArrayList<>();

        for (Taglet current : customTags.values()) {
            if (current.inModule() && !current.isInlineTag()) {
                moduleTags.add(current);
            }
            if (current.inPackage() && !current.isInlineTag()) {
                packageTags.add(current);
            }
            if (current.inType() && !current.isInlineTag()) {
                typeTags.add(current);
            }
            if (current.inField() && !current.isInlineTag()) {
                fieldTags.add(current);
            }
            if (current.inConstructor() && !current.isInlineTag()) {
                constructorTags.add(current);
            }
            if (current.inMethod() && !current.isInlineTag()) {
                methodTags.add(current);
            }
            if (current.isInlineTag()) {
                inlineTags.add(current);
            }
            if (current.inOverview() && !current.isInlineTag()) {
                overviewTags.add(current);
            }
        }

        //Init the serialized form tags
        serializedFormTags = new ArrayList<>();
        serializedFormTags.add(customTags.get(SERIAL_DATA.tagName));
        serializedFormTags.add(customTags.get(THROWS.tagName));
        if (!nosince)
            serializedFormTags.add(customTags.get(SINCE.tagName));
        serializedFormTags.add(customTags.get(SEE.tagName));
    }
140850
protected void initFields() {
		final IEclipsePreferences prefs = SARLEclipsePlugin.getDefault().getPreferences();
		this.trackerLogin.setText(prefs.get(PREFERENCE_LOGIN, "")); //$NON-NLS-1$
	}
1043633
@Override
	public void initialize() {
		Map<String, Parameter> paramMap = new HashMap<>();
		paramMap.putAll(buildConstParamMap());
		paramMap.putAll(buildEnumConstParamMap());

		constParameterMap = Collections.unmodifiableMap(paramMap);
	}
14096
@SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jTextPane1 = new javax.swing.JTextPane();

        setLayout(new java.awt.GridLayout(1, 0));

        jTextPane1.setEditable(false);
        add(jTextPane1);
    }
947981
private function initializeAllDoctrineTypeMappings()
    {
        $this->initializeDoctrineTypeMappings();

        foreach (Type::getTypesMap() as $typeName => $className) {
            foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) {
                $this->doctrineTypeMapping[$dbType] = $typeName;
            }
        }
    }
399596
protected void initFields(Element parent, CmsXmlContentDefinition contentDef) throws CmsXmlException {

        for (Element fieldElem : parent.elements(N_SETTING)) {
            initField(fieldElem, contentDef);
        }
    }
1291624
@Override
    public void initialize(ExtensionContext context) {
        SubsystemRegistration registration = context.registerSubsystem(SUBSYSTEM_NAME, JGroupsModel.CURRENT.getVersion());

        registration.registerSubsystemModel(new JGroupsSubsystemResourceDefinition(context.isRuntimeOnlyRegistrationValid()));
        registration.registerXMLElementWriter(new JGroupsSubsystemXMLWriter());
    }
1141187
public void initializing()
    {
        for (KernelExtension kernelExtension : kernelExtensions.keySet())
        {
            Collection<Plugin> plugins = kernelExtensions.get(kernelExtension);
            kernelExtension.initializing(plugins);
        }
    }
650415
public void initializePackageContents() {
		if (isInitialized) return;
		isInitialized = true;

		// Initialize package
		setName(eNAME);
		setNsPrefix(eNS_PREFIX);
		setNsURI(eNS_URI);

		// Create type parameters

		// Set bounds for type parameters

		// Add supertypes to classes

		// Initialize classes and features; add operations and parameters
		initEClass(documentRootEClass, DocumentRoot.class, "DocumentRoot", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
		initEAttribute(getDocumentRoot_Mixed(), ecorePackage.getEFeatureMapEntry(), "mixed", null, 0, -1, null, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
		initEReference(getDocumentRoot_XMLNSPrefixMap(), ecorePackage.getEStringToStringMapEntry(), null, "xMLNSPrefixMap", null, 0, -1, null, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
		initEReference(getDocumentRoot_XSISchemaLocation(), ecorePackage.getEStringToStringMapEntry(), null, "xSISchemaLocation", null, 0, -1, null, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
		initEAttribute(getDocumentRoot_BackgroundColor(), this.getHexColor(), "backgroundColor", null, 0, 1, null, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
		initEAttribute(getDocumentRoot_BorderColor(), this.getHexColor(), "borderColor", null, 0, 1, null, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
		initEAttribute(getDocumentRoot_Color(), this.getHexColor(), "color", null, 0, 1, null, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

		// Initialize data types
		initEDataType(hexColorEDataType, String.class, "HexColor", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS);

		// Create resource
		createResource(eNS_URI);

		// Create annotations
		// http:///org/eclipse/emf/ecore/util/ExtendedMetaData
		createExtendedMetaDataAnnotations();
	}
246853
private void initFilter() {
        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClass);
        Metamodel metaModel = kunderaMetadata.getApplicationMetadata().getMetamodel(getPersistenceUnit());
        EntityType entityType = metaModel.entity(entityClass);

        if (null == filter) {
            List<String> clauses = new ArrayList<String>();
            addDiscriminatorClause(clauses, entityType);
            return;
        }
        WhereClause whereClause = KunderaQueryUtils.getWhereClause(getJpqlExpression());

        KunderaQueryUtils.traverse(whereClause.getConditionalExpression(), metadata, kunderaMetadata, this, false);

        for (Object filterClause : filtersQueue) {

            if (!(filterClause instanceof String)) {
                onTypedParameter(((FilterClause) filterClause));
            }

        }

        addDiscriminatorClause(null, entityType);
    }
855192
public void initializePackageContents()
  {
    if (isInitialized) return;
    isInitialized = true;

    // Initialize package
    setName(eNAME);
    setNsPrefix(eNS_PREFIX);
    setNsURI(eNS_URI);

    // Create type parameters

    // Set bounds for type parameters

    // Add supertypes to classes
    numberLiteralEClass.getESuperTypes().add(this.getExpression());
    booleanLiteralEClass.getESuperTypes().add(this.getExpression());
    methodCallEClass.getESuperTypes().add(this.getExpression());
    orExpressionEClass.getESuperTypes().add(this.getExpression());
    andExpressionEClass.getESuperTypes().add(this.getExpression());
    comparisonEClass.getESuperTypes().add(this.getExpression());
    notExpressionEClass.getESuperTypes().add(this.getExpression());

    // Initialize classes and features; add operations and parameters
    initEClass(ifConditionEClass, IfCondition.class, "IfCondition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getIfCondition_Elseif(), ecorePackage.getEBoolean(), "elseif", null, 0, 1, IfCondition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getIfCondition_Condition(), this.getExpression(), null, "condition", null, 0, 1, IfCondition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(expressionEClass, Expression.class, "Expression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);

    initEClass(numberLiteralEClass, NumberLiteral.class, "NumberLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getNumberLiteral_Value(), ecorePackage.getEInt(), "value", null, 0, 1, NumberLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(booleanLiteralEClass, BooleanLiteral.class, "BooleanLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getBooleanLiteral_Value(), ecorePackage.getEBoolean(), "value", null, 0, 1, BooleanLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(methodCallEClass, MethodCall.class, "MethodCall", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getMethodCall_Value(), ecorePackage.getEString(), "value", null, 0, 1, MethodCall.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(orExpressionEClass, OrExpression.class, "OrExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getOrExpression_Left(), this.getExpression(), null, "left", null, 0, 1, OrExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getOrExpression_Right(), this.getExpression(), null, "right", null, 0, 1, OrExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(andExpressionEClass, AndExpression.class, "AndExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getAndExpression_Left(), this.getExpression(), null, "left", null, 0, 1, AndExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getAndExpression_Right(), this.getExpression(), null, "right", null, 0, 1, AndExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(comparisonEClass, Comparison.class, "Comparison", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getComparison_Left(), this.getExpression(), null, "left", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getComparison_Operator(), ecorePackage.getEString(), "operator", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getComparison_Right(), this.getExpression(), null, "right", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(notExpressionEClass, NotExpression.class, "NotExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getNotExpression_Expression(), this.getExpression(), null, "expression", null, 0, 1, NotExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    // Create resource
    createResource(eNS_URI);
  }
672177
private void initBeanNameDefaulted(EnhancedAnnotation<T> annotatedAnnotation) {
        if (annotatedAnnotation.isAnnotationPresent(Named.class)) {
            if (!"".equals(annotatedAnnotation.getAnnotation(Named.class).value())) {
                throw MetadataLogger.LOG.valueOnNamedStereotype(annotatedAnnotation);
            }
            beanNameDefaulted = true;
        }
    }