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);
 }
Exemple #10
0
 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());
 }
Exemple #18
0
 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);
 }
Exemple #19
0
  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);
    }
  }
Exemple #22
0
  /*
   * 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);
 }