UncontrolUpdate(
EStructuralFeature.Setting setting,
EObject originalObject,
CDOID originalProxy,
URI destinationURI,
CDOID destinationProxy) {
super(setting);
this.originalObject = originalObject;
this.originalProxy = originalProxy;
this.destinationURI = destinationURI;
this.destinationProxy = destinationProxy;
EStructuralFeature feature = setting.getEStructuralFeature();
InternalEObject owner = (InternalEObject) setting.getEObject();
if (!feature.isMany()) {
index = EStore.NO_INDEX;
} else {
// don't go directly to the store because it may have proxies.
// Use the resolved view in the EObject, instead
index = ((EList<?>) owner.eGet(feature)).indexOf(originalObject);
if (index < 0) {
Activator.log.error(
"Setting does not include the object being replaced by a proxy.",
null); //$NON-NLS-1$
}
}
}
/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
public Expression getArgument() {
if (argument != null && argument.eIsProxy()) {
InternalEObject oldArgument = (InternalEObject) argument;
argument = (Expression) eResolveProxy(oldArgument);
if (argument != oldArgument) {
InternalEObject newArgument = (InternalEObject) argument;
NotificationChain msgs =
oldArgument.eInverseRemove(
this, ExpressionsPackage.EXPRESSION__ARGUMENT_OF, Expression.class, null);
if (newArgument.eInternalContainer() == null) {
msgs =
newArgument.eInverseAdd(
this, ExpressionsPackage.EXPRESSION__ARGUMENT_OF, Expression.class, msgs);
}
if (msgs != null) msgs.dispatch();
if (eNotificationRequired())
eNotify(
new ENotificationImpl(
this,
Notification.RESOLVE,
ExpressionsPackage.EXPRESSION_WITH_ARGUMENT__ARGUMENT,
oldArgument,
argument));
}
}
return argument;
}
/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
public FunctionSignature getCharacteristicFunction() {
if (characteristicFunction != null && characteristicFunction.eIsProxy()) {
InternalEObject oldCharacteristicFunction = (InternalEObject) characteristicFunction;
characteristicFunction = (FunctionSignature) eResolveProxy(oldCharacteristicFunction);
if (characteristicFunction != oldCharacteristicFunction) {
InternalEObject newCharacteristicFunction = (InternalEObject) characteristicFunction;
NotificationChain msgs =
oldCharacteristicFunction.eInverseRemove(
this, ClassesPackage.FUNCTION_SIGNATURE__DIMENSION, FunctionSignature.class, null);
if (newCharacteristicFunction.eInternalContainer() == null) {
msgs =
newCharacteristicFunction.eInverseAdd(
this,
ClassesPackage.FUNCTION_SIGNATURE__DIMENSION,
FunctionSignature.class,
msgs);
}
if (msgs != null) msgs.dispatch();
if (eNotificationRequired())
eNotify(
new ENotificationImpl(
this,
Notification.RESOLVE,
AnalyticsPackage.DIMENSION__CHARACTERISTIC_FUNCTION,
oldCharacteristicFunction,
characteristicFunction));
}
}
return characteristicFunction;
}
/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
public R4EFileVersion getFile() {
if (file != null && file.eIsProxy()) {
InternalEObject oldFile = (InternalEObject) file;
file = (R4EFileVersion) eResolveProxy(oldFile);
if (file != oldFile) {
InternalEObject newFile = (InternalEObject) file;
NotificationChain msgs =
oldFile.eInverseRemove(
this,
EOPPOSITE_FEATURE_BASE - RModelPackage.R4E_ANOMALY_TEXT_POSITION__FILE,
null,
null);
if (newFile.eInternalContainer() == null) {
msgs =
newFile.eInverseAdd(
this,
EOPPOSITE_FEATURE_BASE - RModelPackage.R4E_ANOMALY_TEXT_POSITION__FILE,
null,
msgs);
}
if (msgs != null) msgs.dispatch();
if (eNotificationRequired())
eNotify(
new ENotificationImpl(
this,
Notification.RESOLVE,
RModelPackage.R4E_ANOMALY_TEXT_POSITION__FILE,
oldFile,
file));
}
}
return file;
}
protected static void doRemoveProxy(InternalEObject p, Resource res) {
String id = p.eProxyURI().fragment();
if (res instanceof XMLResource) {
((XMLResource) res).setID(p, id);
}
p.eSetProxyURI(null);
}
/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
public InputPin getTarget() {
if (target != null && target.eIsProxy()) {
InternalEObject oldTarget = (InternalEObject) target;
target = (InputPin) eResolveProxy(oldTarget);
if (target != oldTarget) {
InternalEObject newTarget = (InternalEObject) target;
NotificationChain msgs =
oldTarget.eInverseRemove(
this, EOPPOSITE_FEATURE_BASE - UMLPackage.SEND_SIGNAL_ACTION__TARGET, null, null);
if (newTarget.eInternalContainer() == null) {
msgs =
newTarget.eInverseAdd(
this, EOPPOSITE_FEATURE_BASE - UMLPackage.SEND_SIGNAL_ACTION__TARGET, null, msgs);
}
if (msgs != null) msgs.dispatch();
if (eNotificationRequired())
eNotify(
new ENotificationImpl(
this,
Notification.RESOLVE,
UMLPackage.SEND_SIGNAL_ACTION__TARGET,
oldTarget,
target));
}
}
return target;
}
protected static void doBecomeProxy(InternalEObject p, Resource res) {
String id = res.getURIFragment(p);
p.eSetProxyURI(res.getURI().appendFragment(id));
if (res instanceof XMLResource) {
((XMLResource) res).setID(p, null);
}
p.eAdapters().clear();
}
/** Add the specified list any external resource for this EReference feature */
protected void processReferenceValue(
final Resource eResource,
final EObject eObject,
final EReference eReference,
final EObject value,
final List externalResources,
final Set unresolvedResourceURIs) {
if (value == null) {
return;
}
// Check if the object is an EMF proxy ...
if (value.eIsProxy()) {
if (value instanceof InternalEObject) {
final InternalEObject iObject = (InternalEObject) value;
final URI proxyUri = iObject.eProxyURI();
CoreArgCheck.isNotNull(proxyUri);
// Get the URI of the resource ...
URI resourceUri = proxyUri.trimFragment();
// Make the relative URI absolute if necessary
URI baseLocationUri = eResource.getURI();
URI proxyLocationUri = UriHelper.makeAbsoluteUri(baseLocationUri, resourceUri);
// URI proxyLocationUri = resourceUri;
// if (baseLocationUri.isHierarchical() && !baseLocationUri.isRelative() &&
// proxyUri.isRelative()) {
// proxyLocationUri = proxyLocationUri.resolve(baseLocationUri);
// }
Resource rsrc = findByURI(proxyLocationUri, true);
// If the resource URI is a workspace relative path (e.g. "/project/.../model.xmi")
if (rsrc == null && baseLocationUri.isFile() && resourceUri.toString().charAt(0) == '/') {
String baseLocation = URI.decode(baseLocationUri.toFileString());
String projectName = resourceUri.segment(0);
String proxyLocation = URI.decode(resourceUri.toString());
int index = baseLocation.indexOf(projectName);
if (index != -1) {
proxyLocation = baseLocation.substring(0, index - 1) + proxyLocation;
rsrc = findByURI(URI.createFileURI(proxyLocation), true);
}
}
if (rsrc != null && eResource != rsrc && !externalResources.contains(rsrc)) {
externalResources.add(rsrc);
} else if (rsrc == null) {
unresolvedResourceURIs.add(resourceUri);
}
}
} else {
Resource rsrc = value.eResource();
if (eResource != rsrc && !externalResources.contains(rsrc)) {
externalResources.add(rsrc);
}
}
}
public void addLocalDependency(EStructuralFeature localFeature) {
if (localFeature == null) {
return;
}
if (!source.eClass().getEAllStructuralFeatures().contains(localFeature)) {
return;
}
addLocalDependencyInternal(localFeature);
}
public EObject resolveJavaObjectURIProxy(InternalEObject proxy, JvmTypeReference sender) {
if (indexedJvmTypeAccess != null) {
EObject result = indexedJvmTypeAccess.getIndexedJvmType(proxy.eProxyURI(), getResourceSet());
if (result != null) {
return result;
}
}
return EcoreUtil.resolve(proxy, sender);
}
@Test
public void testProxy() throws Exception {
final XFeatureCall proxy = XbaseFactory.eINSTANCE.createXFeatureCall();
URI _createURI = URI.createURI("path#fragment");
((InternalEObject) proxy).eSetProxyURI(_createURI);
IBatchTypeResolver _typeResolver = this.getTypeResolver();
final IResolvedTypes typeResolution = _typeResolver.resolveTypes(proxy);
Assert.assertNotNull(typeResolution);
Assert.assertEquals(IResolvedTypes.NULL, typeResolution);
}
protected JvmTypeReference getTypeProxy(EObject pointer) {
JvmParameterizedTypeReference typeReference =
typesFactory.createJvmParameterizedTypeReference();
final Resource eResource = pointer.eResource();
String fragment = eResource.getURIFragment(pointer);
URI uri = eResource.getURI();
uri = uri.appendFragment(Xtend2Resource.FRAGMENT_PREFIX + fragment);
((InternalEObject) typeReference).eSetProxyURI(uri);
return typeReference;
}
@Override
public NotificationChain inverseRemove(E object, NotificationChain notifications) {
InternalEObject internalEObject = (InternalEObject) object;
if (hasNavigableInverse()) {
if (!hasInstanceClass()) {
return internalEObject.eInverseRemove(
owner,
internalEObject.eClass().getFeatureID(getInverseEReference()),
null,
notifications);
} else {
return internalEObject.eInverseRemove(
owner, getInverseFeatureID(), getInverseFeatureClass(), notifications);
}
} else {
return internalEObject.eInverseRemove(
owner, InternalEObject.EOPPOSITE_FEATURE_BASE - getFeatureID(), null, notifications);
}
}
@SuppressWarnings("unchecked")
private void refreshDerivedFeature() {
logger.trace("[Notify: " + derivedFeature.getName() + "] Derived refresh.");
try {
if (source.eNotificationRequired()) {
if (type == null) {
type = derivedFeature.getEType();
}
if (derivedFeature.isMany()) {
if (currentValue != null) {
oldValue = new HashSet<EObject>((Collection<EObject>) currentValue);
} else {
oldValue = new HashSet<EObject>();
}
currentValue = new HashSet<EObject>();
Collection<? extends Object> targets =
(Collection<? extends Object>) source.eGet(derivedFeature);
int position = 0;
for (Object target : targets) {
comprehension.traverseFeature(visitor, source, derivedFeature, target, position++);
}
if (currentValue instanceof Collection<?> && oldValue instanceof Collection<?>) {
((Collection<?>) oldValue).removeAll((Collection<?>) currentValue);
if (((Collection<?>) oldValue).size() > 0) {
sendRemoveManyNotification(source, derivedFeature, oldValue);
}
}
} else {
Object target = source.eGet(derivedFeature);
comprehension.traverseFeature(visitor, source, derivedFeature, target, null);
}
}
} catch (Exception ex) {
logger.error(
"The derived feature adapter encountered an error in processing the EMF model. "
+ "This happened while maintaining the derived feature "
+ derivedFeature.getName()
+ " of object "
+ source,
ex);
}
}
protected void convertContent(Object target) {
// if a proxy then do no feature conversions as this may load
// the object
InternalEObject eObject = objectMapping.get(target);
final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(target);
if (getProxyObjects().contains(target)) {
final URI proxyURI = getProxyId(modelObject);
if (proxyURI != null) {
eObject.eSetProxyURI(proxyURI);
}
return;
}
for (final EStructuralFeature eStructuralFeature :
eObject.eClass().getEAllStructuralFeatures()) {
if (!eStructuralFeature.isChangeable() || eStructuralFeature.isVolatile()) {
continue;
}
if (FeatureMapUtil.isFeatureMap(eStructuralFeature)) {
convertFeatureMap(modelObject, eObject, eStructuralFeature);
} else if (eStructuralFeature.isMany()) {
if (eStructuralFeature instanceof EAttribute) {
final EAttribute eAttribute = (EAttribute) eStructuralFeature;
convertManyEAttribute(modelObject, eObject, eAttribute);
} else {
final EReference eReference = (EReference) eStructuralFeature;
convertManyEReference(modelObject, eObject, eReference);
}
} else {
if (eStructuralFeature instanceof EAttribute) {
final EAttribute eAttribute = (EAttribute) eStructuralFeature;
convertSingleEAttribute(modelObject, eObject, eAttribute);
} else {
final EReference eReference = (EReference) eStructuralFeature;
convertSingleEReference(modelObject, eObject, eReference);
}
}
}
}
/**
* Converts the value of an EAttribute with isMany==false, the value is converted ( {@link
* #convertEAttributeValue(Object, EDataType)}) and set in the correct feature in the eObject.
*
* @param modelObject the modelObject from which the value is retrieved.
* @param eObject the eObject in which the value is set (after it has been converted)
* @param eAttribute the EAttribute which is converted
* @see #convertEAttributeValue(Object, EDataType)
*/
protected void convertSingleEAttribute(
final ModelObject<?> modelObject, final EObject eObject, final EAttribute eAttribute) {
final Object value = modelObject.eGet(eAttribute);
// don't set the eObject if the value is null and the attribute is unsettable.
// unsettable is modelled with null in Texo.
if (value == null && ModelUtils.isUnsettable(eAttribute)) {
eObject.eUnset(eAttribute);
return;
}
final Object newValue = convertEAttributeValue(value, eAttribute.getEAttributeType());
((InternalEObject) eObject).eSet(eAttribute, newValue);
}
@Test
public void testBug300216() {
JvmDeclaredType type = (JvmDeclaredType) getTypeProvider().findTypeByName("java.lang.Object");
assertTrue(type.getSuperTypes().isEmpty());
URI unresolveableType = URI.createURI("java:/Objects/Something#Something");
JvmVoid proxy = TypesFactory.eINSTANCE.createJvmVoid();
JvmParameterizedTypeReference typeReference =
TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
typeReference.setType(proxy);
((InternalEObject) proxy).eSetProxyURI(unresolveableType);
type.getSuperTypes().add(typeReference);
assertTrue(type.getSuperTypes().get(0).getType().eIsProxy());
assertEquals(2, type.eResource().getResourceSet().getResources().size());
}
public <
ContainerType extends org.eclipse.emf.ecore.EObject,
ReferenceType extends org.eclipse.emf.ecore.EObject>
void registerContextDependentProxy(
genericity.language.gbind.IGbindContextDependentURIFragmentFactory<
ContainerType, ReferenceType>
factory,
ContainerType container,
org.eclipse.emf.ecore.EReference reference,
String id,
org.eclipse.emf.ecore.EObject proxyElement,
int position) {
org.eclipse.emf.ecore.InternalEObject proxy =
(org.eclipse.emf.ecore.InternalEObject) proxyElement;
String internalURIFragment =
genericity.language.gbind.IGbindContextDependentURIFragment.INTERNAL_URI_FRAGMENT_PREFIX
+ (proxyCounter++)
+ "_"
+ id;
genericity.language.gbind.IGbindContextDependentURIFragment<?> uriFragment =
factory.create(id, container, reference, position, proxy);
proxy.eSetProxyURI(getURI().appendFragment(internalURIFragment));
addURIFragment(internalURIFragment, uriFragment);
}
private EObject createProxy(Resource resource, EClass eClass, JsonNode node) {
EObject proxy = null;
if (isRefNode(node)) {
final URI objectURI = getEObjectURI(node.get(EJS_REF_KEYWORD), resource.getURI(), nsMap);
proxy = EcoreUtil.create(eClass);
((InternalEObject) proxy).eSetProxyURI(objectURI);
if (useProxyAttributes) {
JsonNode refNode = JSUtil.getNode(resource, objectURI, eClass);
if (refNode != null) fillEAttribute(proxy, refNode);
}
}
return proxy;
}
public void addNavigatedDependency(
EStructuralFeature navigationFeature, EStructuralFeature dependantFeature) {
if (navigationFeature == null || dependantFeature == null) {
return;
}
if (!source.eClass().getEAllStructuralFeatures().contains(navigationFeature)) {
return;
}
if (!(navigationFeature.getEType() instanceof EClass)
|| !dependantFeature
.getEContainingClass()
.isSuperTypeOf((EClass) navigationFeature.getEType())) {
return;
}
addNavigatedDependencyInternal(navigationFeature, dependantFeature);
}
/** Resolve to compare objects but do not modify list */
@Override
public boolean contains(Object object) {
if (isEObject()) {
if (size > 4) {
if (!isInstance(object)) {
return false;
} else if (isContainment()) {
InternalEObject eObject = (InternalEObject) object;
EObject eContainer = eObject.eContainer();
boolean result =
eContainer == owner
&& (hasNavigableInverse()
? eObject.eBaseStructuralFeatureID(eObject.eContainerFeatureID(), dataClass)
== getInverseFeatureID()
: InternalEObject.EOPPOSITE_FEATURE_BASE - eObject.eContainerFeatureID()
== getFeatureID());
if (hasProxies() && !result && eContainer == null && eObject.eDirectResource() != null) {
for (int i = 0; i < size; ++i) {
EObject containedEObject = resolveProxy((EObject) data[i]);
if (containedEObject == object) {
return true;
}
}
}
return result;
}
// We can also optimize single valued reverse.
//
else if (hasNavigableInverse() && !hasManyInverse()) {
Object opposite = ((EObject) object).eGet(getInverseEReference());
if (opposite == owner) {
return true;
} else if (opposite == null || !((EObject) opposite).eIsProxy()) {
return false;
}
}
}
boolean result = super.contains(object);
if (hasProxies() && !result) {
for (int i = 0; i < size; ++i) {
EObject eObject = resolveProxy((EObject) data[i]);
if (eObject == object) {
return true;
}
}
}
return result;
} else {
return super.contains(object);
}
}
/*
* IMPORTANT: Compile errors in this method might indicate an old version of EMF. Legacy support is only enabled for
* EMF with fixed bug #247130. These compile errors do not affect native models!
*/
public static InternalCDOObject adaptLegacy(InternalEObject object) {
EList<Adapter> adapters = object.eAdapters();
CDOLegacyAdapter adapter = getLegacyAdapter(adapters);
if (adapter == null) {
adapter = new CDOLegacyAdapter(object);
}
return adapter;
// EList<InternalEObject.EReadListener> readListeners = object.eReadListeners();
// CDOLegacyWrapper wrapper = getLegacyWrapper(readListeners);
// if (wrapper == null)
// {
// wrapper = new CDOLegacyWrapper(object);
// // TODO Only Load/Attach transitions should actually *add* the wrappers!
// readListeners.add(0, wrapper);
// object.eWriteListeners().add(0, wrapper);
// }
//
// return wrapper;
}
private void adjustTransientOppositeReference(
InternalEObject instance, InternalEObject object, EReference oppositeReference) {
boolean wasDeliver = object.eDeliver(); // Disable notifications
if (wasDeliver) {
object.eSetDeliver(false);
}
try {
if (oppositeReference.isMany()) {
@SuppressWarnings("unchecked")
InternalEList<Object> list = (InternalEList<Object>) object.eGet(oppositeReference);
list.basicAdd(instance, null);
} else {
if (object.eGet(oppositeReference) != instance) {
object.eInverseAdd(
instance, oppositeReference.getFeatureID(), ((EObject) instance).getClass(), null);
}
}
} finally {
if (wasDeliver) {
object.eSetDeliver(true);
}
}
}
protected EObject resolveProxy(EObject eObject) {
return eObject.eIsProxy() ? owner.eResolveProxy((InternalEObject) eObject) : eObject;
}
public LightweightTypeReference resolvesTo(final String expression, final String type) {
try {
final XExpression xExpression = this.expression(expression, false);
Resource _eResource = xExpression.eResource();
EList<Diagnostic> _errors = _eResource.getErrors();
String _string = _errors.toString();
Resource _eResource_1 = xExpression.eResource();
EList<Diagnostic> _errors_1 = _eResource_1.getErrors();
boolean _isEmpty = _errors_1.isEmpty();
Assert.assertTrue(_string, _isEmpty);
Resource _eResource_2 = xExpression.eResource();
EList<Diagnostic> _warnings = _eResource_2.getWarnings();
String _string_1 = _warnings.toString();
Resource _eResource_3 = xExpression.eResource();
EList<Diagnostic> _warnings_1 = _eResource_3.getWarnings();
boolean _isEmpty_1 = _warnings_1.isEmpty();
Assert.assertTrue(_string_1, _isEmpty_1);
IBatchTypeResolver _typeResolver = this.getTypeResolver();
final IResolvedTypes resolvedTypes = _typeResolver.resolveTypes(xExpression);
final LightweightTypeReference resolvedType = resolvedTypes.getActualType(xExpression);
String _simpleName = resolvedType.getSimpleName();
Assert.assertEquals(type, _simpleName);
TreeIterator<EObject> _eAllContents = xExpression.eAllContents();
Iterable<EObject> _iterable = IteratorExtensions.<EObject>toIterable(_eAllContents);
for (final EObject content : _iterable) {
boolean _matched = false;
if (!_matched) {
if (content instanceof XSwitchExpression) {
final XSwitchExpression _xSwitchExpression = (XSwitchExpression) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xSwitchExpression, resolvedTypes);
String _localVarName = _xSwitchExpression.getLocalVarName();
boolean _notEquals = (!Objects.equal(_localVarName, null));
if (_notEquals) {
this.assertIdentifiableTypeIsResolved(_xSwitchExpression, resolvedTypes);
}
}
}
if (!_matched) {
if (content instanceof XAbstractFeatureCall) {
final XAbstractFeatureCall _xAbstractFeatureCall = (XAbstractFeatureCall) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xAbstractFeatureCall, resolvedTypes);
XExpression _implicitReceiver = _xAbstractFeatureCall.getImplicitReceiver();
boolean _notEquals = (!Objects.equal(_implicitReceiver, null));
if (_notEquals) {
XExpression _implicitReceiver_1 = _xAbstractFeatureCall.getImplicitReceiver();
this.assertExpressionTypeIsResolved(_implicitReceiver_1, resolvedTypes);
}
}
}
if (!_matched) {
if (content instanceof XExpression) {
final XExpression _xExpression = (XExpression) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xExpression, resolvedTypes);
}
}
if (!_matched) {
if (content instanceof JvmIdentifiableElement) {
final JvmIdentifiableElement _jvmIdentifiableElement = (JvmIdentifiableElement) content;
_matched = true;
this.assertIdentifiableTypeIsResolved(_jvmIdentifiableElement, resolvedTypes);
}
}
}
TreeIterator<EObject> _eAllContents_1 = xExpression.eAllContents();
Iterable<EObject> _iterable_1 = IteratorExtensions.<EObject>toIterable(_eAllContents_1);
for (final EObject content_1 : _iterable_1) {
boolean _matched_1 = false;
if (!_matched_1) {
if (content_1 instanceof XConstructorCall) {
final XConstructorCall _xConstructorCall = (XConstructorCall) content_1;
_matched_1 = true;
Object _eGet = _xConstructorCall.eGet(Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, false);
final InternalEObject constructor = ((InternalEObject) _eGet);
String _string_2 = _xConstructorCall.toString();
Assert.assertNotNull(_string_2, constructor);
String _string_3 = _xConstructorCall.toString();
boolean _eIsProxy = constructor.eIsProxy();
Assert.assertFalse(_string_3, _eIsProxy);
}
}
if (!_matched_1) {
if (content_1 instanceof XAbstractFeatureCall) {
final XAbstractFeatureCall _xAbstractFeatureCall = (XAbstractFeatureCall) content_1;
_matched_1 = true;
Object _eGet =
_xAbstractFeatureCall.eGet(Literals.XABSTRACT_FEATURE_CALL__FEATURE, false);
final InternalEObject feature = ((InternalEObject) _eGet);
String _string_2 = _xAbstractFeatureCall.toString();
Assert.assertNotNull(_string_2, feature);
String _string_3 = _xAbstractFeatureCall.toString();
boolean _eIsProxy = feature.eIsProxy();
Assert.assertFalse(_string_3, _eIsProxy);
XExpression _implicitReceiver = _xAbstractFeatureCall.getImplicitReceiver();
boolean _notEquals = (!Objects.equal(_implicitReceiver, null));
if (_notEquals) {
XExpression _implicitReceiver_1 = _xAbstractFeatureCall.getImplicitReceiver();
Object _eGet_1 =
_implicitReceiver_1.eGet(Literals.XABSTRACT_FEATURE_CALL__FEATURE, false);
final InternalEObject implicitFeature = ((InternalEObject) _eGet_1);
String _string_4 = implicitFeature.toString();
Assert.assertNotNull(_string_4, feature);
String _string_5 = implicitFeature.toString();
boolean _eIsProxy_1 = feature.eIsProxy();
Assert.assertFalse(_string_5, _eIsProxy_1);
}
}
}
}
Resource _eResource_4 = xExpression.eResource();
Iterable<Diagnostic> _linkingAndSyntaxErrors = this.getLinkingAndSyntaxErrors(_eResource_4);
String _string_2 = _linkingAndSyntaxErrors.toString();
Resource _eResource_5 = xExpression.eResource();
Iterable<Diagnostic> _linkingAndSyntaxErrors_1 = this.getLinkingAndSyntaxErrors(_eResource_5);
boolean _isEmpty_2 = IterableExtensions.isEmpty(_linkingAndSyntaxErrors_1);
Assert.assertTrue(_string_2, _isEmpty_2);
Resource _eResource_6 = xExpression.eResource();
EList<Diagnostic> _warnings_2 = _eResource_6.getWarnings();
String _string_3 = _warnings_2.toString();
Resource _eResource_7 = xExpression.eResource();
EList<Diagnostic> _warnings_3 = _eResource_7.getWarnings();
boolean _isEmpty_3 = _warnings_3.isEmpty();
Assert.assertTrue(_string_3, _isEmpty_3);
return resolvedType;
} catch (Throwable _e) {
throw Exceptions.sneakyThrow(_e);
}
}
public EStructuralFeature getEStructuralFeature() {
return owner.eClass().getEStructuralFeature(getFeatureID());
}
@Override
public int getFeatureID() {
return owner.eClass().getFeatureID(getEStructuralFeature());
}
@Override
public void apply() {
InternalEObject object = (InternalEObject) CDOUtil.getEObject(this.object);
store.setContainer(object, null, object.eInternalContainer(), object.eContainerFeatureID());
}
@Override
protected boolean isNotificationRequired() {
return owner.eNotificationRequired();
}
@Override
protected void dispatchNotification(Notification notification) {
owner.eNotify(notification);
}