public static string getID(EObject eObject)
{
EClass eClass = eObject.eClass();
EAttribute eIDAttribute = eClass.eIDAttribute;
return(eIDAttribute == null || !eObject.eIsSet(eIDAttribute) ? null : convertToString(
eIDAttribute.eAttributeType,
eObject.eGet(eIDAttribute)));
}
protected bool validate_DataValueConforms(EObject eObject, EAttribute eAttribute, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
if (!eObject.eIsSet(eAttribute))
{
return(true);
}
bool result = true;
EDataType eDataType = eAttribute.eAttributeType;
EValidator rootValidator = getRootEValidator(context);
object value = eObject.eGet(eAttribute);
/*
* if (FeatureMapUtil.isFeatureMap(eAttribute))
* {
* Collection<FeatureMap.Entry> featureMap = (Collection<FeatureMap.Entry>)value;
* EClass eClass = eObject.eClass();
* Dictionary<EStructuralFeature, DiagnosticChain> entryFeatureToDiagnosticChainMap = null;
* for (Iterator<FeatureMap.Entry> i = featureMap.iterator(); i.hasNext() && (result || diagnostics != null);)
* {
* FeatureMap.Entry entry = i.next();
* EStructuralFeature entryFeature = entry.getEStructuralFeature();
* if (entryFeature instanceof EAttribute &&
* ExtendedMetaData.INSTANCE.getAffiliation(eClass, entryFeature) == eAttribute)
* {
* EDataType entryType = (EDataType)entryFeature.getEType();
* Object entryValue = entry.getValue();
* bool entryIsValid = rootValidator.validate(entryType, entryValue, null, context);
* if (!entryIsValid)
* {
* result = false;
* if (diagnostics != null)
* {
* if (entryFeatureToDiagnosticChainMap == null)
* {
* entryFeatureToDiagnosticChainMap = new HashMap<EStructuralFeature, DiagnosticChain>();
* }
* DiagnosticChain entryFeatureDiagnostic = entryFeatureToDiagnosticChainMap.get(entryFeature);
* if (entryFeatureDiagnostic == null)
* {
* entryFeatureDiagnostic = createBadDataValueDiagnostic(eObject, (EAttribute)entryFeature, diagnostics, context);
* entryFeatureToDiagnosticChainMap.put(entryFeature, entryFeatureDiagnostic);
* }
* rootValidator.validate(entryType, entryValue, entryFeatureDiagnostic, context);
* }
* }
* }
* }
* }
* else*/
if (eAttribute.many)
{
foreach (object item in value as IList <object> )
{
result &= rootValidator.validate(eDataType, item, null, context);
}
if (!result && diagnostics != null)
{
DiagnosticChain diagnostic = createBadDataValueDiagnostic(eObject, eAttribute, diagnostics, context);
foreach (object item in value as IList <object> )
{
rootValidator.validate(eDataType, item, diagnostic, context);
}
}
}
else if (value != null)
{
result = rootValidator.validate(eDataType, value, null, context);
if (!result && diagnostics != null)
{
DiagnosticChain diagnostic = createBadDataValueDiagnostic(eObject, eAttribute, diagnostics, context);
rootValidator.validate(eDataType, value, diagnostic, context);
}
}
return(result);
}
public bool validate_EveryProxyResolves(EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
foreach (EReference reference in eObject.eClass().eAllReferences)
{
if (eObject.eIsSet(reference))
{
EObject eCrossReferenceObject = eObject.eGet(reference) as EObject;
if (eCrossReferenceObject.eIsProxy())
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_PROXY_RESOLVES,
"_UI_UnresolvedProxy_diagnostic",
new Object[]
{
getFeatureLabel(reference, context),
getObjectLabel(eObject, context),
getObjectLabel(eCrossReferenceObject, context)
},
new Object[] { eObject, reference, eCrossReferenceObject },
context));
}
else
{
break;
}
}
}
}
//for (EContentsEList.FeatureIterator<EObject> i = (EContentsEList.FeatureIterator<EObject>)eObject.eCrossReferences().iterator(); i.hasNext();)
/*
* foreach (EObject eCrossReferenceObject in eObject.eCrossReferences())
* {
* //EObject eCrossReferenceObject = i.next();
* if (eCrossReferenceObject.eIsProxy())
* {
* result = false;
* if (diagnostics != null)
* {
* diagnostics.add
* (createDiagnostic
* (BasicDiagnostic.ERROR,
* DIAGNOSTIC_SOURCE,
* EOBJECT__EVERY_PROXY_RESOLVES,
* "_UI_UnresolvedProxy_diagnostic",
* new Object[]
* {
* getFeatureLabel(i.feature(), context),
* getObjectLabel(eObject, context),
* getObjectLabel(eCrossReferenceObject, context)
* },
* new Object[] { eObject, i.feature(), eCrossReferenceObject },
* context));
* }
* else
* {
* break;
* }
* }
* }
*/
return(result);
}
public bool validate_EveryReferenceIsContained(EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
if (eObject.eResource() != null)
{
foreach (EReference reference in eObject.eClass().eAllReferences)
{
if (eObject.eIsSet(reference))
{
EObject eCrossReferenceObject = eObject.eGet(reference) as EObject;
if (eCrossReferenceObject.eResource() == null && !eCrossReferenceObject.eIsProxy() && !reference.transient)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_REFERENCE_IS_CONTAINED,
"_UI_DanglingReference_diagnostic",
new Object[]
{
getFeatureLabel(reference, context),
getObjectLabel(eObject, context),
getObjectLabel(eCrossReferenceObject, context)
},
new Object[] { eObject, reference, eCrossReferenceObject },
context));
}
else
{
break;
}
}
}
}
/*
* for (EContentsEList.FeatureIterator<EObject> i = (EContentsEList.FeatureIterator<EObject>)eObject.eCrossReferences().iterator(); i.hasNext();)
* {
* EObject eCrossReferenceObject = i.next();
* if (eCrossReferenceObject.eResource() == null && !eCrossReferenceObject.eIsProxy() && !i.feature().isTransient())
* {
* result = false;
* if (diagnostics != null)
* {
* diagnostics.add
* (createDiagnostic
* (BasicDiagnostic.ERROR,
* DIAGNOSTIC_SOURCE,
* EOBJECT__EVERY_REFERENCE_IS_CONTAINED,
* "_UI_DanglingReference_diagnostic",
* new Object[]
* {
* getFeatureLabel(i.feature(), context),
* getObjectLabel(eObject, context),
* getObjectLabel(eCrossReferenceObject, context)
* },
* new Object[] { eObject, i.feature(), eCrossReferenceObject },
* context));
* }
* else
* {
* break;
* }
* }
* }
*/
}
return(result);
}
protected bool validate_MultiplicityConforms
(EObject eObject, EStructuralFeature eStructuralFeature, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
if (eStructuralFeature.many)
{
if (false)
{
/*
* if (FeatureMapUtil.isFeatureMap(eStructuralFeature) && ExtendedMetaData.INSTANCE.isDocumentRoot(eObject.eClass()))
* {
* FeatureMap featureMap = (FeatureMap)eObject.eGet(eStructuralFeature);
* int count = 0;
* for (int i = 0, size = featureMap.size(); i < size; ++i)
* {
* EStructuralFeature feature = featureMap.getEStructuralFeature(i);
* int kind = ExtendedMetaData.INSTANCE.getFeatureKind(feature);
* if (kind == ExtendedMetaData.ELEMENT_FEATURE &&
* feature != XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__CDATA &&
* feature != XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__COMMENT &&
* feature != XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__TEXT &&
* feature != XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__PROCESSING_INSTRUCTION &&
++count > 1)
* {
* result = false;
* break;
* }
* }
* if (count != 1)
* {
* result = false;
* if (diagnostics != null)
* {
* diagnostics.add
* (createDiagnostic
* (Diagnostic.ERROR,
* DIAGNOSTIC_SOURCE,
* EOBJECT__EVERY_MULTIPCITY_CONFORMS,
* "_UI_DocumentRootMustHaveOneElement_diagnostic",
* new Object[]
* {
* getFeatureLabel(eStructuralFeature, context),
* getObjectLabel(eObject, context),
* count
* },
* new Object[] { eObject, eStructuralFeature },
* context));
* }
* }
*/
}
else
{
int lowerBound = eStructuralFeature.lowerBound;
if (lowerBound > 0)
{
int size = ((List <object>)eObject.eGet(eStructuralFeature)).Count;
if (size < lowerBound)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_MULTIPCITY_CONFORMS,
"_UI_FeatureHasTooFewValues_diagnostic",
new Object[]
{
getFeatureLabel(eStructuralFeature, context),
getObjectLabel(eObject, context),
size,
lowerBound
},
new Object[] { eObject, eStructuralFeature },
context));
}
}
int upperBound = eStructuralFeature.upperBound;
if (upperBound > 0 && size > upperBound)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_MULTIPCITY_CONFORMS,
"_UI_FeatureHasTooManyValues_diagnostic",
new Object[]
{
getFeatureLabel(eStructuralFeature, context),
getObjectLabel(eObject, context),
size,
upperBound
},
new Object[] { eObject, eStructuralFeature },
context));
}
}
}
else
{
int upperBound = eStructuralFeature.upperBound;
if (upperBound > 0)
{
int size = ((List <object>)eObject.eGet(eStructuralFeature)).Count;
if (size > upperBound)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_MULTIPCITY_CONFORMS,
"_UI_FeatureHasTooManyValues_diagnostic",
new Object[]
{
getFeatureLabel(eStructuralFeature, context),
getObjectLabel(eObject, context),
size,
upperBound
},
new Object[] { eObject, eStructuralFeature },
context));
}
}
}
}
}
}
else if (eStructuralFeature.required)
{
if (eStructuralFeature.unsettable ? !eObject.eIsSet(eStructuralFeature) : eObject.eGet(eStructuralFeature, false) == null)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_MULTIPCITY_CONFORMS,
"_UI_RequiredFeatureMustBeSet_diagnostic",
new Object[] { getFeatureLabel(eStructuralFeature, context), getObjectLabel(eObject, context) },
new Object[] { eObject, eStructuralFeature },
context));
}
}
}
return(result);
}