## org.eclipse.emf.ecore.util
Class EcoreValidator

    java.lang.Object
      org.eclipse.emf.ecore.util.EObjectValidator
          org.eclipse.emf.ecore.util.EcoreValidator

All Implemented Interfaces:
  EValidator

    public class EcoreValidator

extends EObjectValidator

The Validator for the model.

See Also:
  `EcorePackage`

Nested Class Summary
`static class` `EcoreValidator.EGenericTypeBuilder` A utility for parsing generic types and generic type parameters.

Nested classes/interfaces inherited from class org.eclipse.emf.ecore.util.EObjectValidator
`EObjectValidator.DynamicEDataTypeValidator`

Nested classes/interfaces inherited from interface org.eclipse.emf.ecore.EValidator
`EValidator.Descriptor, EValidator.PatternMatcher, EValidator.Registry, EValidator.SubstitutionLabelProvider`

Field Summary
`static int` `AT_MOST_ONE_ID`
`static int` `CONSISTENT_ARGUMENTS_INCORRECT_NUMBER`
`static int` `CONSISTENT_ARGUMENTS_INVALID_SUBSTITUTION`
`static int` `CONSISTENT_ARGUMENTS_NONE`
`static int` `CONSISTENT_ARGUMENTS_NONE_ALLOWED`
`static int` `CONSISTENT_BOUNDS`
`static int` `CONSISTENT_BOUNDS_NO_BOUNDS_WITH_TYPE_PARAMETER_OR_CLASSIFIER`
`static int` `CONSISTENT_BOUNDS_NO_LOWER_AND_UPPER`
`static int` `CONSISTENT_BOUNDS_NOT_ALLOWED`
`static int` `CONSISTENT_KEYS`
`static int` `CONSISTENT_OPPOSITE_BAD_TRANSIENT`
`static int` `CONSISTENT_OPPOSITE_BOTH_CONTAINMENT`
`static int` `CONSISTENT_OPPOSITE_NOT_FROM_TYPE`
`static int` `CONSISTENT_OPPOSITE_NOT_MATCHING`
`static int` `CONSISTENT_SUPER_TYPES_CONFLICT`
`static int` `CONSISTENT_SUPER_TYPES_DUPLICATE`
`static int` `CONSISTENT_TRANSIENT`
`static int` `CONSISTENT_TYPE_CLASS_NOT_PERMITTED`
`static int` `CONSISTENT_TYPE_CLASS_REQUIRED`
`static int` `CONSISTENT_TYPE_DATA_TYPE_NOT_PERMITTED`
`static int` `CONSISTENT_TYPE_NO_TYPE_PARAMETER_AND_CLASSIFIER`
`static int` `CONSISTENT_TYPE_PRIMITIVE_TYPE_NOT_PERMITTED`
`static int` `CONSISTENT_TYPE_TYPE_PARAMETER_NOT_IN_SCOPE`
`static int` `CONSISTENT_TYPE_WILDCARD_NOT_PERMITTED`
`protected static int` `DIAGNOSTIC_CODE_COUNT` A constant with a fixed name that can be used as the base value for additional hand written constants in a derived class
`static java.lang.String` `DIAGNOSTIC_SOURCE` A constant for the `source` of diagnostic `codes` from this package
`static int` `DISJOINT_FEATURE_AND_OPERATION_SIGNATURES`
`static EcoreValidator` `INSTANCE` The cached model package
`static int` `INTERFACE_IS_ABSTRACT`
`static int` `NO_CIRCULAR_SUPER_TYPES`
`static int` `NO_REPEATING_VOID`
`static int` `SINGLE_CONTAINER`
`static java.lang.String` `STRICT_NAMED_ELEMENT_NAMES` A key to be used in `context` maps to indicate that stricter validation should be performed to ensure that the name of each named element is a well formed Java identifier.
`static int` `UNIQUE_CLASSIFIER_NAMES`
`static int` `UNIQUE_ENUMERATOR_LITERALS`
`static int` `UNIQUE_ENUMERATOR_NAMES`
`static int` `UNIQUE_FEATURE_NAMES`
`static int` `UNIQUE_NS_URIS`
`static int` `UNIQUE_OPERATION_SIGNATURES`
`static int` `UNIQUE_PARAMETER_NAMES`
`static int` `UNIQUE_SUBPACKAGE_NAMES`
`static int` `UNIQUE_TYPE_PARAMETER_NAMES`
`static int` `VALID_DEFAULT_VALUE_LITERAL`
`static int` `VALID_LOWER_BOUND`
`static int` `VALID_TYPE`
`static int` `VALID_UPPER_BOUND`
`static int` `WELL_FORMED_INSTANCE_TYPE_NAME`
`static int` `WELL_FORMED_MAP_ENTRY_CLASS`
`static int` `WELL_FORMED_MAP_ENTRY_NO_INSTANCE_CLASS_NAME`
`static int` `WELL_FORMED_NAME`
`static int` `WELL_FORMED_NS_PREFIX`
`static int` `WELL_FORMED_NS_URI`
`static int` `WELL_FORMED_SOURCE_URI`
`protected XMLTypeValidator` `xmlTypeValidator` The cached base package validator

Fields inherited from class org.eclipse.emf.ecore.util.EObjectValidator

`DATA_VALUE__FRACTION_DIGITS_IN_RANGE, DATA_VALUE__LENGTH_IN_RANGE, DATA_VALUE__MATCHES_PATTERN, DATA_VALUE__TOTAL_DIGITS_IN_RANGE, DATA_VALUE__TYPE_CORRECT, DATA_VALUE__VALUE_IN_ENUMERATION, DATA_VALUE__VALUE_IN_RANGE, EOBJECT__EVERY_DATA_VALUE_CONFORMS, EOBJECT__EVERY_KEY_UNIQUE, EOBJECT__EVERY_MAP_ENTRY_UNIQUE, EOBJECT__EVERY_MULTIPCITY_CONFORMS, EOBJECT__EVERY_PROXY_RESOLVES, EOBJECT__EVERY_REFERENCE_IS_CONTAINED, EOBJECT__UNIQUE_ID`

Fields inherited from interface org.eclipse.emf.ecore.EValidator
`MARKER, RELATED_URIS_ATTRIBUTE, URI_ATTRIBUTE`

Constructor Summary
`EcoreValidator()` Creates an instance of the switch

Method Summary
`static boolean` `equalTypeArguments(EGenericType eGenericType1, EGenericType eGenericType2, java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)`
`static boolean` `equalTypeArguments(EList<EGenericType> eTypeArguments1, EList<EGenericType> eTypeArguments2, java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)`
`protected EPackage` `getEPackage()` Returns the package of this validator switch
`ResourceLocator` `getResourceLocator()` Returns the resource locator that will be used to fetch messages for this validator's diagnostics
`static boolean` `isBounded(EGenericType eGenericType, EGenericType eBound, java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)` Returns whether the first generic type is bounded by the second.
`protected boolean` `isBuiltinEDataType(EDataType eDataType)`
`static boolean` `isMatching(EGenericType eGenericType, EGenericType eBound, java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)`
`protected boolean` `isValidSubstitution(EGenericType eTypeArgument, ETypeParameter eTypeParameter, java.util.Map<ETypeParameter,EGenericType> substitutions)` Returns whether the generic type argument is a valid substitution for the type parameter.
`protected static boolean` `isWellFormedURI(java.lang.String uri)` A well formed URI string must have a non-zero length, and must encode any special characters such as the space character.
`static boolean` `matchingTypeArguments(EList<EGenericType> eTypeArguments1, EList<EGenericType> eTypeArguments2, java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)`
`protected void` `report(DiagnosticChain diagnostics, java.lang.String key, java.lang.Object[] substitutions, int index, java.util.Map<java.lang.Object,java.lang.Object> context)` Creates a new diagnostic for a problem at the given index.
`protected boolean` `validate(int classifierID, java.lang.Object value, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Calls `validateXXX` for the corresponding classifier of the model
`boolean` `validateEAnnotation_WellFormedSourceURI(EAnnotation eAnnotation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedSourceURI constraint of 'EAnnotation'
`boolean` `validateEAnnotation(EAnnotation eAnnotation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEAttribute_ConsistentTransient(EAttribute eAttribute, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentTransient constraint of 'EAttribute'
`boolean` `validateEAttribute(EAttribute eAttribute, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEBigDecimal(java.math.BigDecimal eBigDecimal, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEBigInteger(java.math.BigInteger eBigInteger, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEBoolean(boolean eBoolean, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEBooleanObject(java.lang.Boolean eBooleanObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEByte(byte eByte, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEByteArray(byte[] eByteArray, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEByteObject(java.lang.Byte eByteObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEChar(char eChar, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateECharacterObject(java.lang.Character eCharacterObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEClass_AtMostOneID(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the AtMostOneID constraint of 'EClass'
`boolean` `validateEClass_ConsistentSuperTypes(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentSuperTypes constraint of 'EClass'
`boolean` `validateEClass_DisjointFeatureAndOperationSignatures(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the DisjointFeatureAndOperationSignatures constraint of 'EClass'
`boolean` `validateEClass_InterfaceIsAbstract(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the InterfaceIsAbstract constraint of 'EClass'
`boolean` `validateEClass_NoCircularSuperTypes(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the NoCircularSuperTypes constraint of 'EClass'
`boolean` `validateEClass_UniqueFeatureNames(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueFeatureNames constraint of 'EClass'
`boolean` `validateEClass_UniqueOperationSignatures(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueOperationSignatures constraint of 'EClass'
`boolean` `validateEClass_WellFormedMapEntryClass(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedMapEntryClass constraint of 'EClass'
`boolean` `validateEClass(EClass eClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEClassifier_UniqueTypeParameterNames(EClassifier eClassifier, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueTypeParameterNames constraint of 'EClassifier'
`boolean` `validateEClassifier_WellFormedInstanceTypeName(EClassifier eClassifier, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedInstanceTypeName constraint of 'EClassifier'
`boolean` `validateEClassifier(EClassifier eClassifier, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEDataType(EDataType eDataType, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEDate(java.util.Date eDate, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEDiagnosticChain(DiagnosticChain eDiagnosticChain, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEDouble(double eDouble, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEDoubleObject(java.lang.Double eDoubleObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEEList(EList<?> eeList, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEEnum_UniqueEnumeratorLiterals(EEnum eEnum, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueEnumeratorLiterals constraint of 'EEnum'
`boolean` `validateEEnum_UniqueEnumeratorNames(EEnum eEnum, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueEnumeratorNames constraint of 'EEnum'
`boolean` `validateEEnum(EEnum eEnum, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEEnumerator(Enumerator eEnumerator, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEEnumLiteral(EEnumLiteral eEnumLiteral, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEFactory(EFactory eFactory, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEFeatureMap(FeatureMap eFeatureMap, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEFeatureMapEntry(FeatureMap.Entry eFeatureMapEntry, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEFloat(float eFloat, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEFloatObject(java.lang.Float eFloatObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEGenericType_ConsistentArguments(EGenericType eGenericType, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentArguments constraint of 'EGeneric Type'
`boolean` `validateEGenericType_ConsistentBounds(EGenericType eGenericType, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentBounds constraint of 'EGeneric Type'
`boolean` `validateEGenericType_ConsistentType(EGenericType eGenericType, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentType constraint of 'EGeneric Type'
`boolean` `validateEGenericType(EGenericType eGenericType, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEInt(int eInt, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEIntegerObject(java.lang.Integer eIntegerObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEJavaClass(java.lang.Class<?> eJavaClass, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEJavaObject(java.lang.Object eJavaObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateELong(long eLong, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateELongObject(java.lang.Long eLongObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEMap(java.util.Map<?,?> eMap, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEModelElement(EModelElement eModelElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateENamedElement_WellFormedName(ENamedElement eNamedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedName constraint of 'ENamed Element'
`boolean` `validateENamedElement(ENamedElement eNamedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEObject(EObject eObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEOperation_NoRepeatingVoid(EOperation eOperation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the NoRepeatingVoid constraint of 'EOperation'
`boolean` `validateEOperation_UniqueParameterNames(EOperation eOperation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueParameterNames constraint of 'EOperation'
`boolean` `validateEOperation_UniqueTypeParameterNames(EOperation eOperation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueTypeParameterNames constraint of 'EOperation'
`boolean` `validateEOperation(EOperation eOperation, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEPackage_UniqueClassifierNames(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueClassifierNames constraint of 'EPackage'
`boolean` `validateEPackage_UniqueNsURIs(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueNsURIs constraint of 'EPackage'
`boolean` `validateEPackage_UniqueSubpackageNames(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the UniqueSubpackageNames constraint of 'EPackage'
`boolean` `validateEPackage_WellFormedNsPrefix(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedNsPrefix constraint of 'EPackage'
`boolean` `validateEPackage_WellFormedNsURI(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the WellFormedNsURI constraint of 'EPackage'
`boolean` `validateEPackage(EPackage ePackage, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEParameter(EParameter eParameter, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEReference_ConsistentKeys(EReference eReference, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentKeys constraint of 'EReference'
`boolean` `validateEReference_ConsistentOpposite(EReference eReference, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentOpposite constraint of 'EReference'
`boolean` `validateEReference_SingleContainer(EReference eReference, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the SingleContainer constraint of 'EReference'
`boolean` `validateEReference(EReference eReference, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEResource(Resource eResource, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEResourceSet(ResourceSet eResourceSet, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEShort(short eShort, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEShortObject(java.lang.Short eShortObject, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEString(java.lang.String eString, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEStringToStringMapEntry(java.util.Map.Entry<?,?> eStringToStringMapEntry, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateEStructuralFeature_ValidDefaultValueLiteral(EStructuralFeature eStructuralFeature, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ValidDefaultValueLiteral constraint of 'EStructural Feature'
`boolean` `validateEStructuralFeature(EStructuralFeature eStructuralFeature, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateETreeIterator(TreeIterator<?> eTreeIterator, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateETypedElement_ConsistentBounds(ETypedElement eTypedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ConsistentBounds constraint of 'ETyped Element'
`boolean` `validateETypedElement_ValidLowerBound(ETypedElement eTypedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ValidLowerBound constraint of 'ETyped Element'
`boolean` `validateETypedElement_ValidType(ETypedElement eTypedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ValidType constraint of 'ETyped Element'
`boolean` `validateETypedElement_ValidUpperBound(ETypedElement eTypedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)` Validates the ValidUpperBound constraint of 'ETyped Element'
`boolean` `validateETypedElement(ETypedElement eTypedElement, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`
`boolean` `validateETypeParameter(ETypeParameter eTypeParameter, DiagnosticChain diagnostics, java.util.Map<java.lang.Object,java.lang.Object> context)`

Methods inherited from class org.eclipse.emf.ecore.util.EObjectValidator

`createBadDataValueDiagnostic, createDiagnostic, getEcoreResourceLocator, getEcoreString, getFeatureLabel, getObjectLabel, getRootEValidator, getString, getValueLabel, reportDataValuePatternViolation, reportDataValueTypeViolation, reportEnumerationViolation, reportFractionDigitsViolation, reportMaxLengthViolation, reportMaxViolation, reportMinLengthViolation, reportMinViolation, reportTotalDigitsViolation, validate_DataValueConforms, validate_EveryDataValueConforms, validate_EveryDefaultConstraint, validate_EveryKeyUnique, validate_EveryMapEntryUnique, validate_EveryMultiplicityConforms, validate_EveryProxyResolves, validate_EveryReferenceIsContained, validate_KeyUnique, validate_MapEntryUnique, validate_MultiplicityConforms, validate_UniqueID, validate, validate, validate, validatePattern, wrapEnumerationValues`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### INSTANCE

    public static final EcoreValidator INSTANCE

  The cached model package

### STRICT_NAMED_ELEMENT_NAMES

    public static final java.lang.String STRICT_NAMED_ELEMENT_NAMES

  A key to be used in `context` maps to indicate that stricter validation should be performed to ensure that the name of each named element is a well formed Java identifier. The value of the entry must be a `Boolean`. The default value is `Boolean.TRUE`.

  Since:
    2.4
  See Also:
    `EValidator.validate(EObject, DiagnosticChain, Map)`, `validateENamedElement_WellFormedName(ENamedElement, DiagnosticChain, Map)`, Constant Field Values

### DIAGNOSTIC_SOURCE

    public static final java.lang.String DIAGNOSTIC_SOURCE

  A constant for the `source` of diagnostic `codes` from this package.

  See Also:
    `Diagnostic.getSource()`, `Diagnostic.getCode()`, Constant Field Values

### AT_MOST_ONE_ID

    public static final int AT_MOST_ONE_ID

See Also:
  `validateEClass_AtMostOneID(EClass, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_ARGUMENTS_INCORRECT_NUMBER

    public static final int CONSISTENT_ARGUMENTS_INCORRECT_NUMBER

See Also:
  `validateEGenericType_ConsistentArguments(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_ARGUMENTS_INVALID_SUBSTITUTION

    public static final int CONSISTENT_ARGUMENTS_INVALID_SUBSTITUTION

See Also:
  `validateEGenericType_ConsistentArguments(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_ARGUMENTS_NONE

    public static final int CONSISTENT_ARGUMENTS_NONE

See Also:
  `validateEGenericType_ConsistentArguments(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_ARGUMENTS_NONE_ALLOWED

    public static final int CONSISTENT_ARGUMENTS_NONE_ALLOWED

See Also:
  `validateEGenericType_ConsistentArguments(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_BOUNDS

    public static final int CONSISTENT_BOUNDS

See Also:
  `validateETypedElement_ConsistentBounds(ETypedElement, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_BOUNDS_NOT_ALLOWED

    public static final int CONSISTENT_BOUNDS_NOT_ALLOWED

See Also:
  `validateEGenericType_ConsistentBounds(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_BOUNDS_NO_BOUNDS_WITH_TYPE_PARAMETER_OR_CLASSIFIER

    public static final int CONSISTENT_BOUNDS_NO_BOUNDS_WITH_TYPE_PARAMETER_OR_CLASSIFIER

See Also:
  `validateEGenericType_ConsistentBounds(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_BOUNDS_NO_LOWER_AND_UPPER

    public static final int CONSISTENT_BOUNDS_NO_LOWER_AND_UPPER

See Also:
  `validateEGenericType_ConsistentBounds(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_KEYS

    public static final int CONSISTENT_KEYS

See Also:
  `validateEReference_ConsistentKeys(EReference, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_OPPOSITE_BAD_TRANSIENT

    public static final int CONSISTENT_OPPOSITE_BAD_TRANSIENT

See Also:
  `validateEReference_ConsistentOpposite(EReference, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_OPPOSITE_BOTH_CONTAINMENT

    public static final int CONSISTENT_OPPOSITE_BOTH_CONTAINMENT

See Also:
  `validateEReference_ConsistentOpposite(EReference, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_OPPOSITE_NOT_FROM_TYPE

    public static final int CONSISTENT_OPPOSITE_NOT_FROM_TYPE

See Also:
  `validateEReference_ConsistentOpposite(EReference, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_OPPOSITE_NOT_MATCHING

    public static final int CONSISTENT_OPPOSITE_NOT_MATCHING

See Also:
  `validateEReference_ConsistentOpposite(EReference, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_SUPER_TYPES_CONFLICT

    public static final int CONSISTENT_SUPER_TYPES_CONFLICT

See Also:
  `validateEClass_ConsistentSuperTypes(EClass, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_SUPER_TYPES_DUPLICATE

    public static final int CONSISTENT_SUPER_TYPES_DUPLICATE

See Also:
  `validateEClass_ConsistentSuperTypes(EClass, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TRANSIENT

    public static final int CONSISTENT_TRANSIENT

See Also:
  `validateEAttribute_ConsistentTransient(EAttribute, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_CLASS_REQUIRED

    public static final int CONSISTENT_TYPE_CLASS_REQUIRED

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_CLASS_NOT_PERMITTED

    public static final int CONSISTENT_TYPE_CLASS_NOT_PERMITTED

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_DATA_TYPE_NOT_PERMITTED

    public static final int CONSISTENT_TYPE_DATA_TYPE_NOT_PERMITTED

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_NO_TYPE_PARAMETER_AND_CLASSIFIER

    public static final int CONSISTENT_TYPE_NO_TYPE_PARAMETER_AND_CLASSIFIER

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_PRIMITIVE_TYPE_NOT_PERMITTED

    public static final int CONSISTENT_TYPE_PRIMITIVE_TYPE_NOT_PERMITTED

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_TYPE_PARAMETER_NOT_IN_SCOPE

    public static final int CONSISTENT_TYPE_TYPE_PARAMETER_NOT_IN_SCOPE

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### CONSISTENT_TYPE_WILDCARD_NOT_PERMITTED

    public static final int CONSISTENT_TYPE_WILDCARD_NOT_PERMITTED

See Also:
  `validateEGenericType_ConsistentType(EGenericType, DiagnosticChain, Map)`, Constant Field Values

### INTERFACE_IS_ABSTRACT

    public static final int INTERFACE_IS_ABSTRACT

See Also:
  `validateEClass_InterfaceIsAbstract(EClass, DiagnosticChain, Map)`, Constant Field Values

### NO_CIRCULAR_SUPER_TYPES

    public static final int NO_CIRCULAR_SUPER_TYPES

See Also:
  `validateEClass_NoCircularSuperTypes(EClass, DiagnosticChain, Map)`, Constant Field Values

### NO_REPEATING_VOID

    public static final int NO_REPEATING_VOID

See Also:
  `validateEOperation_NoRepeatingVoid(EOperation, DiagnosticChain, Map)`, Constant Field Values

### SINGLE_CONTAINER

    public static final int SINGLE_CONTAINER

See Also:
  `validateEReference_SingleContainer(EReference, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_CLASSIFIER_NAMES

    public static final int UNIQUE_CLASSIFIER_NAMES

See Also:
  `validateEPackage_UniqueClassifierNames(EPackage, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_ENUMERATOR_LITERALS

    public static final int UNIQUE_ENUMERATOR_LITERALS

See Also:
  `validateEEnum_UniqueEnumeratorNames(EEnum, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_ENUMERATOR_NAMES

    public static final int UNIQUE_ENUMERATOR_NAMES

See Also:
  `validateEEnum_UniqueEnumeratorNames(EEnum, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_FEATURE_NAMES

    public static final int UNIQUE_FEATURE_NAMES

See Also:
  `validateEClass_UniqueFeatureNames(EClass, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_NS_URIS

    public static final int UNIQUE_NS_URIS

See Also:
  `validateEPackage_UniqueNsURIs(EPackage, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_OPERATION_SIGNATURES

    public static final int UNIQUE_OPERATION_SIGNATURES

See Also:
  `validateEClass_UniqueOperationSignatures(EClass, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_PARAMETER_NAMES

    public static final int UNIQUE_PARAMETER_NAMES

See Also:
  `validateEOperation_UniqueParameterNames(EOperation, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_SUBPACKAGE_NAMES

    public static final int UNIQUE_SUBPACKAGE_NAMES

See Also:
  `validateEPackage_UniqueSubpackageNames(EPackage, DiagnosticChain, Map)`, Constant Field Values

### UNIQUE_TYPE_PARAMETER_NAMES

    public static final int UNIQUE_TYPE_PARAMETER_NAMES

See Also:
  `validateEOperation_UniqueParameterNames(EOperation, DiagnosticChain, Map)`, `validateEClassifier_UniqueTypeParameterNames(EClassifier, DiagnosticChain, Map)`, Constant Field Values

### VALID_DEFAULT_VALUE_LITERAL

    public static final int VALID_DEFAULT_VALUE_LITERAL

See Also:
  `validateEStructuralFeature_ValidDefaultValueLiteral(EStructuralFeature, DiagnosticChain, Map)`, Constant Field Values

### VALID_LOWER_BOUND

    public static final int VALID_LOWER_BOUND

See Also:
  `validateETypedElement_ValidLowerBound(ETypedElement, DiagnosticChain, Map)`, Constant Field Values

### VALID_TYPE

    public static final int VALID_TYPE

See Also:
  `validateETypedElement_ValidType(ETypedElement, DiagnosticChain, Map)`, Constant Field Values

### VALID_UPPER_BOUND

    public static final int VALID_UPPER_BOUND

See Also:
  `validateETypedElement_ValidUpperBound(ETypedElement, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_INSTANCE_TYPE_NAME

    public static final int WELL_FORMED_INSTANCE_TYPE_NAME

See Also:
  `validateEClassifier_WellFormedInstanceTypeName(EClassifier, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_MAP_ENTRY_CLASS

    public static final int WELL_FORMED_MAP_ENTRY_CLASS

See Also:
  `validateEClass_WellFormedMapEntryClass(EClass, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_NAME

    public static final int WELL_FORMED_NAME

See Also:
  `validateEClass_WellFormedMapEntryClass(EClass, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_NS_PREFIX

    public static final int WELL_FORMED_NS_PREFIX

See Also:
  `validateEPackage_WellFormedNsPrefix(EPackage, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_NS_URI

    public static final int WELL_FORMED_NS_URI

See Also:
  `validateEPackage_WellFormedNsURI(EPackage, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_SOURCE_URI

    public static final int WELL_FORMED_SOURCE_URI

See Also:
  `validateEAnnotation_WellFormedSourceURI(EAnnotation, DiagnosticChain, Map)`, Constant Field Values

### DISJOINT_FEATURE_AND_OPERATION_SIGNATURES

    public static final int DISJOINT_FEATURE_AND_OPERATION_SIGNATURES

See Also:
  `validateEClass_DisjointFeatureAndOperationSignatures(EClass, DiagnosticChain, Map)`, Constant Field Values

### WELL_FORMED_MAP_ENTRY_NO_INSTANCE_CLASS_NAME

    public static final int WELL_FORMED_MAP_ENTRY_NO_INSTANCE_CLASS_NAME

See Also:
  `validateEClass_WellFormedMapEntryClass(EClass, DiagnosticChain, Map)`, Constant Field Values

### DIAGNOSTIC_CODE_COUNT

    protected static final int DIAGNOSTIC_CODE_COUNT

  A constant with a fixed name that can be used as the base value for additional hand written constants in a derived class.

  See Also:
    Constant Field Values

### xmlTypeValidator

    protected XMLTypeValidator xmlTypeValidator

  The cached base package validator.

Constructor Detail

### EcoreValidator

    public EcoreValidator()

  Creates an instance of the switch.

Method Detail

### getEPackage

    protected EPackage getEPackage()

  Returns the package of this validator switch.

  Overrides:
    `getEPackage` in class `EObjectValidator`

### validate

    protected boolean validate(int classifierID,
                               java.lang.Object value,
                               DiagnosticChain diagnostics,
                               java.util.Map<java.lang.Object,java.lang.Object> context)

  Calls `validateXXX` for the corresponding classifier of the model.

  Overrides:
    `validate` in class `EObjectValidator`

### validateEAttribute

    public boolean validateEAttribute(EAttribute eAttribute,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEAttribute_ConsistentTransient

    public boolean validateEAttribute_ConsistentTransient(EAttribute eAttribute,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentTransient constraint of 'EAttribute'.

### validateEAnnotation

    public boolean validateEAnnotation(EAnnotation eAnnotation,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEAnnotation_WellFormedSourceURI

    public boolean validateEAnnotation_WellFormedSourceURI(EAnnotation eAnnotation,
                                                           DiagnosticChain diagnostics,
                                                           java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedSourceURI constraint of 'EAnnotation'. The source URI must either be either `null` or `well formed`.

### isWellFormedURI

    protected static boolean isWellFormedURI(java.lang.String uri)

  A well formed URI string must have a non-zero length, and must encode any special characters such as the space character. As such, creating a `URI`, ignoring the properly encoded characters, and converting that to a `string`, must yield this URI string itself.

  Parameters:
    `uri` - the URI string in question.
  Returns:
    whether the URI is well formed.

### validateEClass

    public boolean validateEClass(EClass eClass,
                                  DiagnosticChain diagnostics,
                                  java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEClass_InterfaceIsAbstract

    public boolean validateEClass_InterfaceIsAbstract(EClass eClass,
                                                      DiagnosticChain diagnostics,
                                                      java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the InterfaceIsAbstract constraint of 'EClass'. A class that is an interface must be abstract.

### validateEClass_AtMostOneID

    public boolean validateEClass_AtMostOneID(EClass eClass,
                                              DiagnosticChain diagnostics,
                                              java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the AtMostOneID constraint of 'EClass'. There can be at most one attribute that is an ID.

### validateEClass_UniqueFeatureNames

    public boolean validateEClass_UniqueFeatureNames(EClass eClass,
                                                     DiagnosticChain diagnostics,
                                                     java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueFeatureNames constraint of 'EClass'. No two features may have matching names. Feature names are matched ignoring their case and their underscore separators. It is an error to have two features with names that are equal but only a warning to have two features with names that match.

### validateEClass_UniqueOperationSignatures

    public boolean validateEClass_UniqueOperationSignatures(EClass eClass,
                                                            DiagnosticChain diagnostics,
                                                            java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueOperationSignatures constraint of 'EClass'. No two operations defined in the same class may have matching signatures. The signature is determined by the name of the operation and the types of its parameters. If the name is the same and the types match, the signatures match. Types match if they are the same classifier, or both classifiers have instance class names that are the same.

### validateEClass_NoCircularSuperTypes

    public boolean validateEClass_NoCircularSuperTypes(EClass eClass,
                                                       DiagnosticChain diagnostics,
                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the NoCircularSuperTypes constraint of 'EClass'. A super type must not appear in its own list of all super types.

### validateEClass_WellFormedMapEntryClass

    public boolean validateEClass_WellFormedMapEntryClass(EClass eClass,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedMapEntryClass constraint of 'EClass'. A map entry class must have features named 'key' and 'value'.

### validateEClass_ConsistentSuperTypes

    public boolean validateEClass_ConsistentSuperTypes(EClass eClass,
                                                       DiagnosticChain diagnostics,
                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentSuperTypes constraint of 'EClass'. The same class must not occur more than once among the generic super types nor among all the generic super types where occurrences in the latter represent conflicting instantiations of the same classifier.

### validateEClass_DisjointFeatureAndOperationSignatures

    public boolean validateEClass_DisjointFeatureAndOperationSignatures(EClass eClass,
                                                                        DiagnosticChain diagnostics,
                                                                        java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the DisjointFeatureAndOperationSignatures constraint of 'EClass'. Each feature defined in the class is interpreted as implicitly defining the operations with the signatures corresponding to the generated accessors for that feature hence the same type of constraint as `validateEClass_UniqueOperationSignatures(EClass, DiagnosticChain, Map)` applies.

### validateEClassifier

    public boolean validateEClassifier(EClassifier eClassifier,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEClassifier_WellFormedInstanceTypeName

    public boolean validateEClassifier_WellFormedInstanceTypeName(EClassifier eClassifier,
                                                                  DiagnosticChain diagnostics,
                                                                  java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedInstanceTypeName constraint of 'EClassifier'. The instance type name may be null only for a class or an enum and must be `well formed` when not null.

### validateEClassifier_UniqueTypeParameterNames

    public boolean validateEClassifier_UniqueTypeParameterNames(EClassifier eClassifier,
                                                                DiagnosticChain diagnostics,
                                                                java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueTypeParameterNames constraint of 'EClassifier'.

### validateEDataType

    public boolean validateEDataType(EDataType eDataType,
                                     DiagnosticChain diagnostics,
                                     java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEEnum

    public boolean validateEEnum(EEnum eEnum,
                                 DiagnosticChain diagnostics,
                                 java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEEnum_UniqueEnumeratorNames

    public boolean validateEEnum_UniqueEnumeratorNames(EEnum eEnum,
                                                       DiagnosticChain diagnostics,
                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueEnumeratorNames constraint of 'EEnum'. No two enum literals may have matching names. Literal names are matched ignoring their case and their underscore separators. It is an error to have two enum literals with names that are equal but only a warning to have two enum literals with names that match.

### validateEEnum_UniqueEnumeratorLiterals

    public boolean validateEEnum_UniqueEnumeratorLiterals(EEnum eEnum,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueEnumeratorLiterals constraint of 'EEnum'. No two enum literals may have the same literal value.

### validateEEnumLiteral

    public boolean validateEEnumLiteral(EEnumLiteral eEnumLiteral,
                                        DiagnosticChain diagnostics,
                                        java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEFactory

    public boolean validateEFactory(EFactory eFactory,
                                    DiagnosticChain diagnostics,
                                    java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEModelElement

    public boolean validateEModelElement(EModelElement eModelElement,
                                         DiagnosticChain diagnostics,
                                         java.util.Map<java.lang.Object,java.lang.Object> context)

### validateENamedElement

    public boolean validateENamedElement(ENamedElement eNamedElement,
                                         DiagnosticChain diagnostics,
                                         java.util.Map<java.lang.Object,java.lang.Object> context)

### validateENamedElement_WellFormedName

    public boolean validateENamedElement_WellFormedName(ENamedElement eNamedElement,
                                                        DiagnosticChain diagnostics,
                                                        java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedName constraint of 'ENamed Element'. The name must be a valid Java identifier. I.e., it must start with a `Java identifier start character`, that is followed by zero or more `Java identifier part characters`. This constraint is only enforced in a `STRICT_NAMED_ELEMENT_NAMES` context.

### validateEObject

    public boolean validateEObject(EObject eObject,
                                   DiagnosticChain diagnostics,
                                   java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEOperation

    public boolean validateEOperation(EOperation eOperation,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEOperation_UniqueParameterNames

    public boolean validateEOperation_UniqueParameterNames(EOperation eOperation,
                                                           DiagnosticChain diagnostics,
                                                           java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueParameterNames constraint of 'EOperation'. No two parameters may have the same name.

### validateEOperation_UniqueTypeParameterNames

    public boolean validateEOperation_UniqueTypeParameterNames(EOperation eOperation,
                                                               DiagnosticChain diagnostics,
                                                               java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueTypeParameterNames constraint of 'EOperation'.

### validateEOperation_NoRepeatingVoid

    public boolean validateEOperation_NoRepeatingVoid(EOperation eOperation,
                                                      DiagnosticChain diagnostics,
                                                      java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the NoRepeatingVoid constraint of 'EOperation'. An operation without a type, which represents void, must have an upper bound of 1.

### validateEPackage

    public boolean validateEPackage(EPackage ePackage,
                                    DiagnosticChain diagnostics,
                                    java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEPackage_WellFormedNsURI

    public boolean validateEPackage_WellFormedNsURI(EPackage ePackage,
                                                    DiagnosticChain diagnostics,
                                                    java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedNsURI constraint of 'EPackage'. The namespace URI must be `well formed` and may not be `null`.

### validateEPackage_WellFormedNsPrefix

    public boolean validateEPackage_WellFormedNsPrefix(EPackage ePackage,
                                                       DiagnosticChain diagnostics,
                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the WellFormedNsPrefix constraint of 'EPackage'. The namespace prefix must be either `null` or a `valid NCName` that does not start with the any case combination of the three letters "xml".

### validateEPackage_UniqueSubpackageNames

    public boolean validateEPackage_UniqueSubpackageNames(EPackage ePackage,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueSubpackageNames constraint of 'EPackage'. No two packages my have the same name.

### validateEPackage_UniqueClassifierNames

    public boolean validateEPackage_UniqueClassifierNames(EPackage ePackage,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueClassifierNames constraint of 'EPackage'. No two classifiers may have matching names. Classifier names are matched ignoring their case and their underscore separators. It is an error to have two classifier with names that are equal but only a warning to have two classifiers with names that match.

### validateEPackage_UniqueNsURIs

    public boolean validateEPackage_UniqueNsURIs(EPackage ePackage,
                                                 DiagnosticChain diagnostics,
                                                 java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the UniqueNsURIs constraint of 'EPackage'.

### validateEParameter

    public boolean validateEParameter(EParameter eParameter,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEReference

    public boolean validateEReference(EReference eReference,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEReference_ConsistentOpposite

    public boolean validateEReference_ConsistentOpposite(EReference eReference,
                                                         DiagnosticChain diagnostics,
                                                         java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentOpposite constraint of 'EReference'. An `opposite` is optional but if one exists, it must be a feature of this references's `type`, it must have this reference as its opposite, and, if this feature is `transient`, then the opposite must also be transient, must not `resolve proxies`. or must be a `containment`,

### validateEReference_SingleContainer

    public boolean validateEReference_SingleContainer(EReference eReference,
                                                      DiagnosticChain diagnostics,
                                                      java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the SingleContainer constraint of 'EReference'. A `container` reference must have a upper bound of 1.

### validateEReference_ConsistentKeys

    public boolean validateEReference_ConsistentKeys(EReference eReference,
                                                     DiagnosticChain diagnostics,
                                                     java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentKeys constraint of 'EReference'. The `keys` of a reference must be features of the reference's `ETypedElement.getEType()`.

### validateEStructuralFeature

    public boolean validateEStructuralFeature(EStructuralFeature eStructuralFeature,
                                              DiagnosticChain diagnostics,
                                              java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEStructuralFeature_ValidDefaultValueLiteral

    public boolean validateEStructuralFeature_ValidDefaultValueLiteral(EStructuralFeature eStructuralFeature,
                                                                       DiagnosticChain diagnostics,
                                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ValidDefaultValueLiteral constraint of 'EStructural Feature'.

### isBuiltinEDataType

    protected boolean isBuiltinEDataType(EDataType eDataType)

### validateETypedElement

    public boolean validateETypedElement(ETypedElement eTypedElement,
                                         DiagnosticChain diagnostics,
                                         java.util.Map<java.lang.Object,java.lang.Object> context)

### validateETypedElement_ValidLowerBound

    public boolean validateETypedElement_ValidLowerBound(ETypedElement eTypedElement,
                                                         DiagnosticChain diagnostics,
                                                         java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ValidLowerBound constraint of 'ETyped Element'. The `lower bound` must be greater or equal to 0

### validateETypedElement_ValidUpperBound

    public boolean validateETypedElement_ValidUpperBound(ETypedElement eTypedElement,
                                                         DiagnosticChain diagnostics,
                                                         java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ValidUpperBound constraint of 'ETyped Element'. The `upper bound` must be either `ETypedElement.UNBOUNDED_MULTIPLICITY`, `ETypedElement.UNSPECIFIED_MULTIPLICITY`, or greater than 0.

### validateETypedElement_ConsistentBounds

    public boolean validateETypedElement_ConsistentBounds(ETypedElement eTypedElement,
                                                          DiagnosticChain diagnostics,
                                                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentBounds constraint of 'ETyped Element'. The `lower bound` must be less than or equal to the `upper bound`, unless the upper bound is one of the two special values `ETypedElement.UNBOUNDED_MULTIPLICITY` or `ETypedElement.UNSPECIFIED_MULTIPLICITY`.

### validateETypedElement_ValidType

    public boolean validateETypedElement_ValidType(ETypedElement eTypedElement,
                                                   DiagnosticChain diagnostics,
                                                   java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ValidType constraint of 'ETyped Element'. The `type` may be `null` only if this in an `operation`.

### validateEStringToStringMapEntry

    public boolean validateEStringToStringMapEntry(java.util.Map.Entry<?,?> eStringToStringMapEntry,
                                                   DiagnosticChain diagnostics,
                                                   java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEGenericType

    public boolean validateEGenericType(EGenericType eGenericType,
                                        DiagnosticChain diagnostics,
                                        java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEGenericType_ConsistentType

    public boolean validateEGenericType_ConsistentType(EGenericType eGenericType,
                                                       DiagnosticChain diagnostics,
                                                       java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentType constraint of 'EGeneric Type'. A generic type must not reference both a `classifier` and a `type parameter`. The referenced type parameter must be in scope, i.e., its `EObject.eContainer()` must be an `EcoreUtil.isAncestor(EObject, EObject)` of this generic type. A generic type used as a `generic super type` must have a classifier that refers to a `class`. A generic type used as a `type argument` of a generic type used as a generic super type must specify either a classifier or a type parameter, i.e., it can't be a wildcard. A generic type may omit both the classifier and the type argument to act as a wildcard only when used as a type argument of some generic type, with the above exception. If present, the classifier of generic type used as the `type` of an `attribute` must be a `data type`. If present, the classifier of generic type used as the type of a `reference` must be a class.

### validateEGenericType_ConsistentBounds

    public boolean validateEGenericType_ConsistentBounds(EGenericType eGenericType,
                                                         DiagnosticChain diagnostics,
                                                         java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentBounds constraint of 'EGeneric Type'. A generic type may have bounds only when used as a `type argument`. A generic type may not have both a `lower` and an `upper bound`. A generic type may not have bounds as well as a `classifier` or a `type parameter`.

### validateEGenericType_ConsistentArguments

    public boolean validateEGenericType_ConsistentArguments(EGenericType eGenericType,
                                                            DiagnosticChain diagnostics,
                                                            java.util.Map<java.lang.Object,java.lang.Object> context)

  Validates the ConsistentArguments constraint of 'EGeneric Type'. A generic type can have `type arguments` only if it has a `classifier` that specifies `EClassifier.getETypeParameters()`; the number of type arguments must match the number of type parameters. It is only a warning for there to be no arguments when there are parameters, but any other mismatch is an error.

### isValidSubstitution

    protected boolean isValidSubstitution(EGenericType eTypeArgument,
                                          ETypeParameter eTypeParameter,
                                          java.util.Map<ETypeParameter,EGenericType> substitutions)

  Returns whether the generic type argument is a valid substitution for the type parameter. A generic type is a valid substitution if it is `bounded` by every `bound` of the type parameter. It follows that for a type parameter without bounds, every type argument is a valid substitution.

  Parameters:
    `eTypeArgument` - the generic type argument to consider.
    `eTypeParameter` - the type parameter in question.
  Returns:
    whether the generic type argument is a valid substitution for the type parameter.

### isBounded

    public static boolean isBounded(EGenericType eGenericType,
                                    EGenericType eBound,
                                    java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)

  Returns whether the first generic type is bounded by the second. If they both reference a classifier, then the classifier of the first must be bounded by the classifier of the second, and the type arguments must `match`. A classifier is bounded by another classifier, if they are the same classifier, if both are classes and the first is a `EClass.isSuperTypeOf(EClass)` the second, or if both have an non-null `instance class` for which the first is `assignable from` the second, or, failing all these, if they have non-null `EClassifier.getInstanceTypeName()` that are equal. If the bound references a classifier, and the generic type argument references a type parameter, one of the `bounds` of that type parameter must be bounded by bound. If the bound has a `lower bound`, the generic type argument must be bounded by that lower bound. If the bound has an `upper bound`, the generic type argument must be bounded by that upper bound. If the bound references a type parameter, the generic type argument must be bounded by every bound of that type parameter. If the bound has a lower bound, the generic type argument must be bounded by it. If the bound has an upper bound, the generic type argument must be bound that upper bound. Failing all these cases, the bound is a wildcard with no constraint, and the type argument is bounded.

  Parameters:
    `eGenericType` - the generic type in question.
    `eBound` - the bound it's being assessed against.
    `substitutions` - the map of substitutions that are in effect.
  Returns:
    whether the first generic type is bounded by the second.

### matchingTypeArguments

    public static boolean matchingTypeArguments(EList<EGenericType> eTypeArguments1,
                                                EList<EGenericType> eTypeArguments2,
                                                java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)

### isMatching

    public static boolean isMatching(EGenericType eGenericType,
                                     EGenericType eBound,
                                     java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)

### equalTypeArguments

    public static boolean equalTypeArguments(EList<EGenericType> eTypeArguments1,
                                             EList<EGenericType> eTypeArguments2,
                                             java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)

### equalTypeArguments

    public static boolean equalTypeArguments(EGenericType eGenericType1,
                                             EGenericType eGenericType2,
                                             java.util.Map<? extends ETypeParameter,? extends EGenericType> substitutions)

### validateETypeParameter

    public boolean validateETypeParameter(ETypeParameter eTypeParameter,
                                          DiagnosticChain diagnostics,
                                          java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEBigDecimal

    public boolean validateEBigDecimal(java.math.BigDecimal eBigDecimal,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEBigInteger

    public boolean validateEBigInteger(java.math.BigInteger eBigInteger,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEBoolean

    public boolean validateEBoolean(boolean eBoolean,
                                    DiagnosticChain diagnostics,
                                    java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEBooleanObject

    public boolean validateEBooleanObject(java.lang.Boolean eBooleanObject,
                                          DiagnosticChain diagnostics,
                                          java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEByte

    public boolean validateEByte(byte eByte,
                                 DiagnosticChain diagnostics,
                                 java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEByteArray

    public boolean validateEByteArray(byte[] eByteArray,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEByteObject

    public boolean validateEByteObject(java.lang.Byte eByteObject,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEChar

    public boolean validateEChar(char eChar,
                                 DiagnosticChain diagnostics,
                                 java.util.Map<java.lang.Object,java.lang.Object> context)

### validateECharacterObject

    public boolean validateECharacterObject(java.lang.Character eCharacterObject,
                                            DiagnosticChain diagnostics,
                                            java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEDate

    public boolean validateEDate(java.util.Date eDate,
                                 DiagnosticChain diagnostics,
                                 java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEDiagnosticChain

    public boolean validateEDiagnosticChain(DiagnosticChain eDiagnosticChain,
                                            DiagnosticChain diagnostics,
                                            java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEDouble

    public boolean validateEDouble(double eDouble,
                                   DiagnosticChain diagnostics,
                                   java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEDoubleObject

    public boolean validateEDoubleObject(java.lang.Double eDoubleObject,
                                         DiagnosticChain diagnostics,
                                         java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEEList

    public boolean validateEEList(EList<?> eeList,
                                  DiagnosticChain diagnostics,
                                  java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEEnumerator

    public boolean validateEEnumerator(Enumerator eEnumerator,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEFeatureMap

    public boolean validateEFeatureMap(FeatureMap eFeatureMap,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEFeatureMapEntry

    public boolean validateEFeatureMapEntry(FeatureMap.Entry eFeatureMapEntry,
                                            DiagnosticChain diagnostics,
                                            java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEFloat

    public boolean validateEFloat(float eFloat,
                                  DiagnosticChain diagnostics,
                                  java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEFloatObject

    public boolean validateEFloatObject(java.lang.Float eFloatObject,
                                        DiagnosticChain diagnostics,
                                        java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEInt

    public boolean validateEInt(int eInt,
                                DiagnosticChain diagnostics,
                                java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEIntegerObject

    public boolean validateEIntegerObject(java.lang.Integer eIntegerObject,
                                          DiagnosticChain diagnostics,
                                          java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEJavaClass

    public boolean validateEJavaClass(java.lang.Class<?> eJavaClass,
                                      DiagnosticChain diagnostics,
                                      java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEJavaObject

    public boolean validateEJavaObject(java.lang.Object eJavaObject,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateELong

    public boolean validateELong(long eLong,
                                 DiagnosticChain diagnostics,
                                 java.util.Map<java.lang.Object,java.lang.Object> context)

### validateELongObject

    public boolean validateELongObject(java.lang.Long eLongObject,
                                       DiagnosticChain diagnostics,
                                       java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEMap

    public boolean validateEMap(java.util.Map<?,?> eMap,
                                DiagnosticChain diagnostics,
                                java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEResource

    public boolean validateEResource(Resource eResource,
                                     DiagnosticChain diagnostics,
                                     java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEResourceSet

    public boolean validateEResourceSet(ResourceSet eResourceSet,
                                        DiagnosticChain diagnostics,
                                        java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEShort

    public boolean validateEShort(short eShort,
                                  DiagnosticChain diagnostics,
                                  java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEShortObject

    public boolean validateEShortObject(java.lang.Short eShortObject,
                                        DiagnosticChain diagnostics,
                                        java.util.Map<java.lang.Object,java.lang.Object> context)

### validateEString

    public boolean validateEString(java.lang.String eString,
                                   DiagnosticChain diagnostics,
                                   java.util.Map<java.lang.Object,java.lang.Object> context)

### validateETreeIterator

    public boolean validateETreeIterator(TreeIterator<?> eTreeIterator,
                                         DiagnosticChain diagnostics,
                                         java.util.Map<java.lang.Object,java.lang.Object> context)

### getResourceLocator

    public ResourceLocator getResourceLocator()

  Returns the resource locator that will be used to fetch messages for this validator's diagnostics.

  Overrides:
    `getResourceLocator` in class `EObjectValidator`
  Returns:
    the resource locator for fetching model-specific messages.

### report

    protected void report(DiagnosticChain diagnostics,
                          java.lang.String key,
                          java.lang.Object[] substitutions,
                          int index,
                          java.util.Map<java.lang.Object,java.lang.Object> context)

  Creates a new diagnostic for a problem at the given index.

  Parameters:
    `diagnostics` - the target for the new diagnostic.
    `key` - the key for the message.
    `substitutions` - the substitutions for the key; `null` if there are no substitutions.
    `index` - the index at which the problem occurred.
  Since:
    2.4
  See Also:
    `EcoreValidator.EGenericTypeBuilder.report(DiagnosticChain, String, Object[], int)`

Copyright 2001-2006 IBM Corporation and others. All Rights Reserved.