private void ConvertProperty(MetaClassBuilder mcls, EStructuralFeature eprop)
{
var mprop = _factory.MetaProperty();
mprop.Name = eprop.Name.ToPascalCase();
mcls.Properties.Add(mprop);
_map.Add(eprop, mprop);
if (eprop.Derived)
{
mprop.Kind = MetaPropertyKind.Derived;
}
else if (eprop.Unsettable || !eprop.Changeable)
{
mprop.Kind = MetaPropertyKind.Readonly;
}
mprop.DefaultValue = eprop.DefaultValueLiteral;
if (eprop is EAttribute eattr)
{
if (eattr.ID && eattr.EType == EcoreInstance.EString)
{
mprop.Attributes.Add(MetaInstance.NameAttribute.ToMutable());
}
}
else if (eprop is EReference eref)
{
mprop.IsContainment = eref.Containment;
}
}
private void initEStructuralFeature
(EStructuralFeature s,
EGenericType type,
String name,
String defaultValue,
int lowerBound,
int upperBound,
Type containerClass,
bool isTransient,
bool isVolatile,
bool isChangeable,
bool isUnsettable,
bool isUnique,
bool isDerived,
bool isOrdered)
{
s.name = name;
((EStructuralFeatureImpl)s).containerClass = containerClass;
s.transient = isTransient;
s.volatile_ = isVolatile;
s.changeable = isChangeable;
s.unsettable = isUnsettable;
s.unique = isUnique;
s.derived = isDerived;
s.ordered = isOrdered;
s.lowerBound = lowerBound;
s.upperBound = upperBound;
s.eGenericType = type;
if (defaultValue != null)
{
s.defaultValueLiteral = defaultValue;
}
}
public Object getFeature()
{
if (feature == null && featureID != NO_FEATURE_ID)
{
EClass eClass = notifier.eClass();
feature = eClass.getEStructuralFeature(featureID);
}
return(feature);
}
/**
* @since 2.1.0
*/
public static string getFeatureLabel(EStructuralFeature eStructuralFeature, Dictionary <object, object> context)
{
/*
* if (context != null)
* {
* //TODO check containskey
* SubstitutionLabelProvider substitutionlabelProvider = (SubstitutionLabelProvider)context[typeof(SubstitutionLabelProvider)];
* if (substitutionlabelProvider != null)
* {
* return substitutionlabelProvider.getFeatureLabel(eStructuralFeature);
* }
* }
*/
return(eStructuralFeature.name);
}
public int eDerivedStructuralFeatureID(EStructuralFeature eStructuralFeature)
{
Type containerClass = null;
/*
* Class <?> containerClass = eStructuralFeature.getContainerClass();
* if (containerClass == null)
* {
* return eClass().getFeatureID(eStructuralFeature);
* }
* else
* {
* assert eClass().getEAllStructuralFeatures().contains(eStructuralFeature) : "The feature '" + eStructuralFeature.getName() + "' is not a valid feature";
*/
return(eDerivedStructuralFeatureID(eStructuralFeature.getFeatureID(), containerClass));
/*}*/
}
public virtual void eSet(EStructuralFeature eFeature, object newValue)
{
int featureID = eDerivedStructuralFeatureID(eFeature);
/*
* if (featureID >= 0)
* {
*/
eSet(featureID, newValue);
/*}
* else
* {
* eOpenSet(eFeature, newValue);
* }
*/
}
public virtual object eGet(EStructuralFeature feature, bool resolve, bool coreType)
{
int featureID = eDerivedStructuralFeatureID(feature);
/*
* if (featureID >= 0)
* {
*/
return(eGet(featureID, resolve, coreType));
/*
* }
* else
* {
* return eOpenGet(eFeature, resolve);
* }
*/
}
public bool validate_EveryKeyUnique(EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
EClass eClass = eObject.eClass();
for (int i = 0, size = eClass.getFeatureCount(); i < size; ++i)
{
EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature(i);
if (eStructuralFeature is EReference)
{
EReference eReference = (EReference)eStructuralFeature;
if (eReference.many && !eReference.eKeys.isEmpty())
{
result &= validate_KeyUnique(eObject, eReference, diagnostics, context);
if (!result && diagnostics == null)
{
return(false);
}
}
}
}
return(result);
}
public bool validateEStructuralFeature(EStructuralFeature obj, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
if (!validate_NoCircularContainment(obj, diagnostics, context))
{
return(false);
}
bool result = validate_EveryMultiplicityConforms(obj, diagnostics, context);
if (result || diagnostics != null)
{
result &= validate_EveryDataValueConforms(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryReferenceIsContained(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryBidirectionalReferenceIsPaired(obj, diagnostics, context);
}
//if (result || diagnostics != null) result &= validate_EveryProxyResolves(obj, diagnostics, context);
if (result || diagnostics != null)
{
result &= validate_UniqueID(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryKeyUnique(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryMapEntryUnique(obj, diagnostics, context);
}
return(result);
}
public override object eGet(EStructuralFeature paramEStructuralFeature, bool parambool)
{
throw new NotImplementedException();
}
public object eGet(EStructuralFeature feature, bool resolve)
{
return(eGet(feature, resolve, true));
}
public object eGet(EStructuralFeature feature)
{
return(eGet(feature, true));
}
public virtual object eGet(EStructuralFeature feature,
bool resolve
)
{
throw new NotImplementedException();
}
public virtual int getFeatureID(EStructuralFeature feature
)
{
throw new NotImplementedException();
}
public virtual EGenericType getFeatureType(EStructuralFeature feature
)
{
throw new NotImplementedException();
}
private void resolve(EObject eobject, EStructuralFeature estructuralfeature, String value)
{
resolveJobs.Add(new Tuple <EObject, EStructuralFeature, string>(eobject, estructuralfeature, value));
}
public virtual void eSet(EStructuralFeature feature,
object newValue
)
{
throw new NotImplementedException();
}
public virtual T caseEStructuralFeature(EStructuralFeature theEObject)
{
return(default(T));
}
public virtual bool eIsSet(EStructuralFeature feature)
{
throw new NotImplementedException();
}
public virtual object eGet(int featureID, bool resolve, bool coreType)
{
EStructuralFeature eFeature = eClass().getEStructuralFeature(featureID);
return(eFeature);
}
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);
}
public virtual void eSet(EStructuralFeature feature, object newValue)
{
eSet(feature.getFeatureID(), newValue);
}
public override void eSet(EStructuralFeature paramEStructuralFeature, object paramObject)
{
throw new NotImplementedException();
}
public virtual void eUnset(EStructuralFeature feature)
{
throw new NotImplementedException();
}
public override bool eIsSet(EStructuralFeature paramEStructuralFeature)
{
throw new NotImplementedException();
}
//NEU ENDE
public string eURIFragmentSegment(EStructuralFeature eFeature, EObject eObject)
{
throw new NotImplementedException();
}
public override void eUnset(EStructuralFeature paramEStructuralFeature)
{
throw new NotImplementedException();
}
