@Override
 public int size(InternalEObject object, EStructuralFeature feature) {
   if (feature instanceof EReference) {
     EReference eReference = (EReference) feature;
     final Map<Object, Object> cache = pCore.getActiveCache();
     if (!(eReference.getEType() instanceof EClass)) {
       return super.size(object, feature);
     }
     PersistentEObject neoEObject =
         NeoEObjectAdapterFactoryImpl.getAdapter(object, PersistentEObject.class);
     NeoEMFIndexedCacheKey key =
         new NeoEMFIndexedCacheKey(neoEObject.id().toString(), eReference, -2);
     if (cache.containsKey(key)) {
       pCore.hit();
       ;
       int cachedSize = (int) cache.get(key);
       if (cachedSize == -1) {
         return 0;
       } else {
         return cachedSize;
       }
     } else {
       pCore.miss();
       ;
       return super.size(object, feature);
     }
   }
   return super.size(object, feature);
 }
 /** {@inheritDoc} Overridden for debugging purposes. */
 @Override
 protected Predicate<Method> getPredicate(EObject context, EReference reference) {
   String methodName =
       "scope_" + reference.getEContainingClass().getName() + "_" + reference.getName();
   //		System.out.println(methodName + " ctx " + context.eClass().getName());
   return PolymorphicDispatcher.Predicates.forName(methodName, 2);
 }
  public void cdoInternalPostDetach(boolean remote) {
    if (remote) {
      setInstanceContainer(null, eContainerFeatureID());
      setInstanceResource(null);
      return;
    }

    // This loop adjusts the opposite wrapper objects to support dangling references. See
    // Bugzilla_251263_Test
    InternalCDORevision revision = cdoRevision();
    for (EReference reference : classInfo.getAllPersistentReferences()) {
      if (!reference.isContainer() && classInfo.hasPersistentOpposite(reference)) {
        if (reference.isMany()) {
          EReference oppositeReference = reference.getEOpposite();

          int size = revision.size(reference);
          for (int i = 0; i < size; i++) {
            EObject object = (EObject) getValueFromRevision(reference, i);
            adjustPersistentOppositeReference(this, object, oppositeReference);
          }
        } else {
          EObject oppositeObject = (EObject) instance.eGet(reference);
          if (oppositeObject != null) {
            EReference oppositeReference = reference.getEOpposite();
            adjustPersistentOppositeReference(this, oppositeObject, oppositeReference);
          }
        }
      }
    }
  }
 public static List<EClass> filterByContainmentFeature(
     Collection<EClass> eClasses, MappingEntry mappingEntry) {
   EClass superType = null;
   if (mappingEntry instanceof NodeMapping) {
     NodeReference nodeReference = (NodeReference) mappingEntry.eContainer();
     if (nodeReference != null) {
       EReference modelReference =
           nodeReference.getChildrenFeature() != null
               ? nodeReference.getChildrenFeature()
               : nodeReference.getContainmentFeature();
       if (modelReference != null) {
         superType = modelReference.getEReferenceType();
       }
     }
   } else if (mappingEntry instanceof LinkMapping) {
     if (((LinkMapping) mappingEntry).getContainmentFeature() != null) {
       superType = ((LinkMapping) mappingEntry).getContainmentFeature().getEReferenceType();
     }
   }
   return sort(
       getConcreteEClasses(
           getSubtypesOf(
               filterValidEObjectsFrom(eClasses, mappingEntry.eResource().getResourceSet()),
               superType)));
 }
 @Override
 public boolean canDelete(IDeleteContext context) {
   // Participant bands in a ChoreographyTask only be "deleted" (from the model)
   // if there are no other references to the participant; but they can be "removed"
   // (from the ChoreographyTask's participantRef list) at any time.
   // @see RemoveChoreographyParticipantFeature
   PictogramElement pe = context.getPictogramElement();
   if (ChoreographyUtil.isChoreographyParticipantBand(pe)) {
     int referenceCount = 0;
     Participant participant = BusinessObjectUtil.getFirstElementOfType(pe, Participant.class);
     Definitions definitions = ModelUtil.getDefinitions(participant);
     TreeIterator<EObject> iter = definitions.eAllContents();
     while (iter.hasNext()) {
       EObject o = iter.next();
       for (EReference reference : o.eClass().getEAllReferences()) {
         if (!reference.isContainment() && !(o instanceof DiagramElement)) {
           if (reference.isMany()) {
             List list = (List) o.eGet(reference);
             for (Object referencedObject : list) {
               if (referencedObject == participant) ++referenceCount;
             }
           } else {
             Object referencedObject = o.eGet(reference);
             if (referencedObject == participant) ++referenceCount;
           }
         }
       }
     }
     return referenceCount <= 1;
   }
   return true;
 }
  /**
   * @see
   *     org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand#doExecuteWithResult(org.eclipse.core.runtime.IProgressMonitor,
   *     org.eclipse.core.runtime.IAdaptable)
   * @param arg0
   * @param arg1
   * @return
   * @throws ExecutionException
   */
  @SuppressWarnings("unchecked")
  @Override
  protected CommandResult doExecuteWithResult(IProgressMonitor arg0, IAdaptable arg1)
      throws ExecutionException {
    Object createdElement = elementAdapter.getAdapter(EObject.class);
    if (createdElement instanceof EObject) {
      EObject eObjectCreatedElement = (EObject) createdElement;
      for (IGraphicalEditPart parent : graphicalParent) {
        EObject eObjectSourceReference = parent.resolveSemanticElement();
        AbstractContainerNodeDescriptor desc =
            GroupContainmentRegistry.getContainerDescriptor(parent);
        List<EReference> refs = desc.getReferenceFor(eObjectCreatedElement.eClass());
        for (EReference ref : refs) {
          if (ref != null && ref.isMany()) {
            Collection<EObject> collection = (Collection<EObject>) eObjectSourceReference.eGet(ref);
            if (!collection.contains(eObjectCreatedElement)) {
              collection.add(eObjectCreatedElement);
            }
          } else if (ref != null && !ref.isMany()) {
            eObjectSourceReference.eSet(ref, eObjectCreatedElement);
          }
        }
      }
    }

    return CommandResult.newOKCommandResult();
  }
 protected void clearReference(EObject obj, EReference ref) {
   if (!ref.isContainment()
       && !ref.isContainer()
       && !ref.isDerived()
       && ref.isChangeable()
       && !ref.isTransient()) obj.eUnset(ref);
 }
Example #8
0
  private void fillEReference(EObject eObject, JsonNode root, Resource resource) {
    final EClass eClass = eObject.eClass();

    for (Iterator<Entry<String, JsonNode>> it = root.getFields(); it.hasNext(); ) {
      Entry<String, JsonNode> field = it.next();

      String key = field.getKey();
      JsonNode value = field.getValue();

      EReference reference = getEReference(eClass, key);
      if (reference != null
          && !reference.isContainment()
          && !reference.isDerived()
          && !reference.isTransient()) {

        if (value.isArray()) {
          for (Iterator<JsonNode> itEl = value.getElements(); itEl.hasNext(); ) {
            JsonNode current = itEl.next();
            createProxyReference(eObject, root, current, reference, resource);
          }
        } else {
          createProxyReference(eObject, root, value, reference, resource);
        }
      }
    }

    for (EObject content : eObject.eContents()) {
      if (processed.containsKey(content)) fillEReference(content, processed.get(content), resource);
    }
  }
  private void init() {
    BasicEList<EStructuralFeature> contains = new UniqueEList<EStructuralFeature>(this.size);
    BasicEList<EStructuralFeature> crossRefs = new UniqueEList<EStructuralFeature>(this.size);

    for (int i = 0; i < this.size; ++i) {
      EStructuralFeature eFeature = (EStructuralFeature) this.data[i];
      if (eFeature instanceof EReference) {
        EReference eReference = (EReference) eFeature;

        if (eReference.isContainment()) {
          contains.add(eReference);
        } else if (!eReference.isContainer()) {
          crossRefs.add(eReference);
        }
      }
    }
    contains.shrink();
    crossRefs.shrink();

    this.containments = new EStructuralFeature[contains.size()];
    this.crossReferences = new EStructuralFeature[crossRefs.size()];
    int i = 0;
    for (EStructuralFeature feature : contains) {
      this.containments[i++] = feature;
    }
    i = 0;
    for (EStructuralFeature feature : crossRefs) {
      this.crossReferences[i++] = feature;
    }
  }
Example #10
0
  private void createContainment(
      EObject eObject, EReference reference, JsonNode root, JsonNode node, Resource resource) {
    if (node.isArray()) {
      if (reference.isMany()) {
        @SuppressWarnings("unchecked")
        EList<EObject> values = (EList<EObject>) eObject.eGet(reference);

        for (Iterator<JsonNode> it = node.getElements(); it.hasNext(); ) {
          JsonNode current = it.next();
          EObject contained = createContainedObject(reference, root, current, resource);
          if (contained != null) values.add(contained);
        }
      } else if (node.getElements().hasNext()) {
        JsonNode current = node.getElements().next();
        EObject contained = createContainedObject(reference, root, current, resource);
        if (contained != null) eObject.eSet(reference, contained);
      }
    } else {
      EObject contained = createContainedObject(reference, root, node, resource);

      if (reference.isMany()) {
        @SuppressWarnings("unchecked")
        EList<EObject> values = (EList<EObject>) eObject.eGet(reference);
        if (contained != null) values.add(contained);
      } else {
        if (contained != null) eObject.eSet(reference, contained);
      }
    }
  }
Example #11
0
 private void setContainmentLink(EObject eObject) {
   if (eObject.eContainer() != null) {
     EObject eContainer = eObject.eContainer();
     EReference eReference = eObject.eContainmentFeature();
     int position =
         eReference.isMany() ? position = getContainmentPosition(eContainer, eObject) : 0;
     addLink(eContainer, eObject, eReference, position);
   }
 }
  private void update(
      EReference ref, EObject eParentObj, EObject eObj, EObject eRef, EObject eDef) {
    if (eObj != null && eObj instanceof DataPointComponent) {
      eDef =
          ChartDefaultValueUtil.getPercentileDataPointDefObj(
              (DataPointComponent) eObj, (DataPointComponent) eDef);
    }

    update(ref.getEReferenceType(), ref.getName(), eParentObj, eObj, eRef, eDef);
  }
Example #13
0
 private static void getNsURI(StringBuilder s, EObject element) {
   if (element instanceof org.eclipse.ocl.examples.pivot.Package) {
     String nsURI = ((org.eclipse.ocl.examples.pivot.Package) element).getNsURI();
     if (nsURI != null) {
       s.append(nsURI);
       return;
     }
   } else if (element instanceof EPackage) {
     String nsURI = ((EPackage) element).getNsURI();
     if (nsURI != null) {
       s.append(nsURI);
       return;
     }
   }
   EObject eContainer = element.eContainer();
   if (eContainer instanceof org.eclipse.ocl.examples.pivot.Package) {
     String nsURI = ((org.eclipse.ocl.examples.pivot.Package) element).getNsURI();
     if (nsURI != null) {
       s.append(nsURI);
       s.append("#/");
     } else {
       getNsURI(s, eContainer);
     }
   } else if (eContainer instanceof EPackage) {
     String nsURI = ((EPackage) element).getNsURI();
     if (nsURI != null) {
       s.append(nsURI);
       s.append("#/");
     } else {
       getNsURI(s, eContainer);
     }
   } else if (eContainer == null) {
     String name = null;
     if (element instanceof org.eclipse.ocl.examples.pivot.Package) {
       name = ((org.eclipse.ocl.examples.pivot.Package) element).getName();
     } else if (element instanceof EPackage) {
       name = ((EPackage) element).getName();
     }
     if (name == null) {
       name = "$null$";
     }
     s.append(name);
     return;
   } else {
     getNsURI(s, eContainer);
   }
   EReference eFeature = element.eContainmentFeature();
   s.append("@");
   s.append(eFeature.getName());
   if (eFeature.isMany()) {
     int index = ((List<?>) eContainer.eGet(element.eContainingFeature())).indexOf(element);
     s.append(".");
     s.append(index);
   }
 }
Example #14
0
 /**
  * Convenient implementation of the {@link #getLinkElements(InternalProject, EObject, EReference)}
  * method to use the {@link ItemPropertyDescriptor} to get all object of an object.
  *
  * @param project the project the call is from
  * @param modelElement {@link EObject} to add the {@link EReference} to
  * @param eReference the {@link EReference} to add
  * @return {@link Iterator} of {@link EObject} that can be linked
  */
 @Override
 public Iterator<EObject> getLinkElements(
     InternalProject project, EObject modelElement, EReference eReference) {
   final EClass elementClass = modelElement.eClass();
   EClassifier type =
       EcoreUtil.getReifiedType(elementClass, eReference.getEGenericType()).getEClassifier();
   if (type == null) {
     type = eReference.getEType();
   }
   return ItemPropertyDescriptor.getReachableObjectsOfType(modelElement, type).iterator();
 }
Example #15
0
  private static void checkObject(
      EObject expected,
      EObject actual,
      Set<EStructuralFeature> excludeFeatures,
      Set<EObject> visited) {
    if (expected == null) {
      assertThat(actual, is(nullValue()));
      return;
    }

    if (visited.contains(expected)) return;

    visited.add(expected);

    assertThat(
        "Actual instance for type '" + expected.eClass().getName() + "' must not be null",
        actual,
        is(notNullValue()));

    for (EAttribute attribute : expected.eClass().getEAllAttributes()) {
      if (!excludeFeatures.contains(attribute))
        assertThat(
            "Attribute '"
                + attribute.getName()
                + "' on class '"
                + expected.eClass().getName()
                + "' did not match",
            actual.eGet(attribute),
            is(expected.eGet(attribute)));
    }

    for (EReference reference : expected.eClass().getEAllReferences()) {
      if (excludeFeatures.contains(reference)) continue;

      if (reference.isMany()) {
        @SuppressWarnings("unchecked")
        EList<EObject> expectedObjects = (EList<EObject>) expected.eGet(reference);
        @SuppressWarnings("unchecked")
        EList<EObject> actualObjects = (EList<EObject>) actual.eGet(reference);
        assertThat(
            "Reference size for '" + reference.getName() + "' does not match",
            actualObjects.size(),
            is(expectedObjects.size()));

        for (int i = 0; i < expectedObjects.size(); i++)
          checkObject(expectedObjects.get(i), actualObjects.get(i), excludeFeatures, visited);
      } else
        checkObject(
            (EObject) expected.eGet(reference),
            (EObject) actual.eGet(reference),
            excludeFeatures,
            visited);
    }
  }
 public void findLocalReferences(
     Set<? extends EObject> targets,
     IAcceptor<IReferenceDescription> acceptor,
     Predicate<IReferenceDescription> filter,
     IProgressMonitor monitor) {
   if (monitor != null && monitor.isCanceled()) return;
   if (targets != null && !targets.isEmpty()) {
     Set<Resource> targetResources = new HashSet<Resource>();
     for (EObject target : targets) {
       targetResources.add(target.eResource());
     }
     Map<EObject, Collection<Setting>> targetResourceInternalCrossRefs =
         CrossReferencer.find(targetResources);
     Map<EObject, URI> exportedElementsMap = null;
     SubMonitor subMonitor =
         SubMonitor.convert(monitor, Messages.ReferenceQuery_monitor, targets.size());
     for (EObject target : targets) {
       Collection<Setting> crossRefSettings = targetResourceInternalCrossRefs.get(target);
       if (crossRefSettings != null) {
         SubMonitor subSubMonitor = subMonitor.newChild(crossRefSettings.size());
         for (Setting crossRefSetting : crossRefSettings) {
           if (subSubMonitor.isCanceled()) return;
           EObject source = crossRefSetting.getEObject();
           if (crossRefSetting.getEStructuralFeature() instanceof EReference) {
             EReference reference = (EReference) crossRefSetting.getEStructuralFeature();
             int index = 0;
             if (reference.isMany()) {
               List<?> values = (List<?>) source.eGet(reference);
               for (int i = 0; i < values.size(); ++i) {
                 if (target == values.get(i)) {
                   index = i;
                   break;
                 }
               }
             }
             if (exportedElementsMap == null)
               exportedElementsMap = createExportedElementsMap(target.eResource());
             IReferenceDescription localReferenceDescription =
                 new DefaultReferenceDescription(
                     source,
                     target,
                     reference,
                     index,
                     findClosestExportedContainerURI(source, exportedElementsMap));
             if (filter == null || filter.apply(localReferenceDescription))
               acceptor.accept(localReferenceDescription);
           }
           subSubMonitor.worked(1);
         }
       }
     }
   }
 }
 /**
  * Returns all valid references for an EObject. This excludes container/containment references. A
  * reference is valid if it is neither derived nor volatile and if it is changeable and either
  * many-valued or not already set.
  *
  * @param eObject the EObject to get references for
  * @param exceptionLog the current log of exceptions
  * @param ignoreAndLog should exceptions be ignored and added to <code>exceptionLog</code>?
  * @return all valid references as a list
  */
 public static List<EReference> getValidReferences(
     EObject eObject, Set<RuntimeException> exceptionLog, boolean ignoreAndLog) {
   List<EReference> result = new LinkedList<EReference>();
   for (EReference reference : eObject.eClass().getEAllReferences()) {
     if (!reference.isContainer()
         && !reference.isContainment()
         && isValid(reference, eObject, exceptionLog, ignoreAndLog)
         && (reference.isMany() || !eObject.eIsSet(reference))) {
       result.add(reference);
     }
   }
   return result;
 }
 public static Collection<EReference> getEReferences(
     Collection<EReference> eReferences, boolean containmentOnly) {
   if (!containmentOnly) {
     return eReferences;
   }
   for (Iterator<EReference> it = eReferences.iterator(); it.hasNext(); ) {
     EReference nextReference = it.next();
     if (nextReference != null && !nextReference.isContainment()) {
       it.remove();
     }
   }
   return eReferences;
 }
 void resolve(EObject object, EReference reference, EObject proxy) {
   EReference opposite = reference.getEOpposite();
   if (opposite != null) {
     if (opposite.isMany()) {
       InternalEList<?> list = (InternalEList<?>) object.eGet(opposite, false);
       int index = list.basicIndexOf(proxy);
       if (index >= 0) {
         list.get(index); // resolve just this index
       }
     } else {
       object.eGet(opposite, true); // resolve the scalar reference
     }
   }
 }
 public void resolveFuzzy(
     String identifier,
     org.eclipse.emf.ecore.EObject container,
     org.eclipse.emf.ecore.EReference reference,
     int position,
     org.emftext.language.office.resource.office.IOfficeReferenceResolveResult<
             org.eclipse.emf.ecore.EObject>
         result) {
   if (container == null) {
     return;
   }
   if (org.emftext.language.office.OfficePackage.eINSTANCE.getEmployee().isInstance(container)) {
     OfficeFuzzyResolveResult<org.emftext.language.office.Office> frr =
         new OfficeFuzzyResolveResult<org.emftext.language.office.Office>(result);
     String referenceName = reference.getName();
     org.eclipse.emf.ecore.EStructuralFeature feature =
         container.eClass().getEStructuralFeature(referenceName);
     if (feature != null
         && feature instanceof org.eclipse.emf.ecore.EReference
         && referenceName != null
         && referenceName.equals("worksIn")) {
       employeeWorksInReferenceResolver.resolve(
           identifier,
           (org.emftext.language.office.Employee) container,
           (org.eclipse.emf.ecore.EReference) feature,
           position,
           true,
           frr);
     }
   }
   if (org.emftext.language.office.OfficePackage.eINSTANCE.getEmployee().isInstance(container)) {
     OfficeFuzzyResolveResult<org.emftext.language.office.Employee> frr =
         new OfficeFuzzyResolveResult<org.emftext.language.office.Employee>(result);
     String referenceName = reference.getName();
     org.eclipse.emf.ecore.EStructuralFeature feature =
         container.eClass().getEStructuralFeature(referenceName);
     if (feature != null
         && feature instanceof org.eclipse.emf.ecore.EReference
         && referenceName != null
         && referenceName.equals("worksWith")) {
       employeeWorksWithReferenceResolver.resolve(
           identifier,
           (org.emftext.language.office.Employee) container,
           (org.eclipse.emf.ecore.EReference) feature,
           position,
           true,
           frr);
     }
   }
 }
Example #21
0
  @Before
  public void before() {
    ePackage = FACTORY.createEPackage();
    ePackage.setName("Package");

    eClass0 = FACTORY.createEClass();
    eClass0.setName("EClass0");
    ePackage.getEClassifiers().add(eClass0);

    eClass1 = FACTORY.createEClass();
    eClass1.setName("EClass1");
    ePackage.getEClassifiers().add(eClass1);

    singleRef = FACTORY.createEReference();
    singleRef.setName("singleRef");
    singleRef.setUpperBound(1);
    singleRef.setEType(eClass1);
    singleRef.setContainment(true);
    eClass0.getEStructuralFeatures().add(singleRef);

    multiRef = FACTORY.createEReference();
    multiRef.setName("multiRef");
    multiRef.setUpperBound(-1);
    multiRef.setEType(eClass0);
    multiRef.setContainment(true);
    eClass1.getEStructuralFeatures().add(multiRef);
  }
 public static Collection<EReference> getEReferencesOfType(
     Collection<EReference> references, EClass referenceType) {
   Collection<EReference> result = getValidEStructuralFeatures(references);
   if (referenceType == null) {
     return result;
   }
   for (Iterator<EReference> it = result.iterator(); it.hasNext(); ) {
     EReference nextFeature = it.next();
     if (nextFeature != null && !nextFeature.getEReferenceType().isSuperTypeOf(referenceType)) {
       it.remove();
     }
   }
   return result;
 }
  protected <
          ContainerType extends org.eclipse.emf.ecore.EObject,
          ReferenceType extends org.eclipse.emf.ecore.EObject>
      void registerContextDependentProxy(
          final ASPM.resource.ASPM.mopp.ASPMContextDependentURIFragmentFactory<
                  ContainerType, ReferenceType>
              factory,
          final ContainerType container,
          final org.eclipse.emf.ecore.EReference reference,
          final String id,
          final org.eclipse.emf.ecore.EObject proxy) {
    final int position;
    if (reference.isMany()) {
      position = ((java.util.List<?>) container.eGet(reference)).size();
    } else {
      position = -1;
    }

    postParseCommands.add(
        new ASPM.resource.ASPM.IASPMCommand<ASPM.resource.ASPM.IASPMTextResource>() {
          public boolean execute(ASPM.resource.ASPM.IASPMTextResource resource) {
            if (resource == null) {
              // the resource can be null if the parser is used for code completion
              return true;
            }
            resource.registerContextDependentProxy(
                factory, container, reference, id, proxy, position);
            return true;
          }
        });
  }
Example #24
0
  private void addLink(
      EObject sourceEObject, EObject targetEObject, EReference eReference, int targetPosition) {
    Object_ sourceObject = map.getObject(sourceEObject);
    Object_ targetObject = map.getObject(targetEObject);
    Association association = getFUMLAssociation(eReference);

    if (hasOppositeReference(eReference)
        && haveProcessedAsOpposite(eReference, sourceObject, targetObject, association)) {
      return;
    }

    // Setup target property end
    LinkCreationData linkData = new LinkCreationData(sourceObject, targetObject, association);
    LinkEndCreationData targetEndData = linkData.createLinkEndCreationData();
    targetEndData.setEnd(getTargetPropertyEnd(eReference, association));
    linkData.setTargetEndData(targetEndData);
    linkData.setTargetPosition(targetPosition);

    // Setup source property end
    LinkEndCreationData sourceEndData = linkData.createLinkEndCreationData();
    if (hasOppositeReference(eReference)) {
      EReference oppositeReference = eReference.getEOpposite();
      sourceEndData.setEnd(getTargetPropertyEnd(oppositeReference, association));
      int sourcePosition = getPosition(targetEObject, oppositeReference, sourceEObject);
      linkData.setSourcePosition(sourcePosition);
      addProcessedOpposite(sourceEndData);
    } else {
      sourceEndData.setEnd(getSourcePropertyEnd(eReference, association));
    }
    linkData.setSourceEndData(sourceEndData);
    Link link = linkData.createNewLink();
    map.addExtensionalValue(link);
    // link.addTo(locus);
    locus.add(link);
  }
  private void handleMultipleResults() {
    org.eclipse.emf.common.util.EList<org.eclipse.emf.ecore.EObject> list = null;
    Object temp = container.eGet(reference);
    if (temp instanceof org.eclipse.emf.common.util.EList<?>) {
      list = org.emftext.sdk.concretesyntax.resource.cs.util.CsCastUtil.cast(temp);
    }

    boolean first = true;
    for (org.emftext.sdk.concretesyntax.resource.cs.ICsReferenceMapping<ReferenceType> mapping :
        result.getMappings()) {
      if (first) {
        first = false;
      } else if (list != null) {
        addResultToList(mapping, proxy, list);
      } else {
        new org.emftext.sdk.concretesyntax.resource.cs.util.CsRuntimeUtil()
            .logError(
                container.eClass().getName()
                    + "."
                    + reference.getName()
                    + " has multiplicity 1 but was resolved to multiple elements",
                null);
      }
    }
  }
 /**
  * Sets or adds to a reference for an EObject with any generated instance of <code>referenceClass
  * </code> using SetCommand/AddCommand. If the reference is not required, <code>random</code>
  * decides whether the reference is set or how many EObjects are added to it.
  *
  * @param eObject the EObject to set the reference for
  * @param referenceClass the EClass all referenced EObject shall be instances of
  * @param reference the reference to set
  * @param random the Random-object that randomizes EObjects and their amount
  * @param exceptionLog the current log of exceptions
  * @param ignoreAndLog should exceptions be ignored and added to <code>exceptionLog</code>?
  * @param allEObjects all existing EObjects mapped to their EClass
  * @see #addPerCommand(EObject, EStructuralFeature, Collection, Set, boolean)
  * @see #addPerCommand(EObject, EStructuralFeature, Object, Set, boolean)
  * @see #setPerCommand(EObject, EStructuralFeature, Object, Set, boolean)
  */
 public static void setReference(
     EObject eObject,
     EClass referenceClass,
     EReference reference,
     Random random,
     Set<RuntimeException> exceptionLog,
     boolean ignoreAndLog,
     Map<EClass, List<EObject>> allEObjects) {
   List<EObject> possibleReferenceObjects = allEObjects.get(referenceClass);
   Collections.shuffle(possibleReferenceObjects, random);
   if (!possibleReferenceObjects.isEmpty()) {
     int index = 0;
     if (reference.isMany()) {
       int numberOfReferences = computeFeatureAmount(reference, random);
       for (int i = 0; i < numberOfReferences; i++) {
         ModelGeneratorUtil.addPerCommand(
             eObject, reference, possibleReferenceObjects.get(index), exceptionLog, ignoreAndLog);
         // ensures every EObject is set at most once
         if (++index == possibleReferenceObjects.size()) {
           break;
         }
       }
       // Change of referencing
       // Delete reference.isRequired() in order to set 0..1 references
       // } else if (reference.isRequired() || random.nextBoolean()){
     } else if (random.nextBoolean()) {
       ModelGeneratorUtil.setPerCommand(
           eObject, reference, possibleReferenceObjects.get(index), exceptionLog, ignoreAndLog);
     }
   }
 }
 protected void computeReferencedJvmTypeHighlighting(
     IHighlightedPositionAcceptor acceptor, EObject referencer, CancelIndicator cancelIndicator) {
   for (EReference reference : referencer.eClass().getEAllReferences()) {
     EClass referencedType = reference.getEReferenceType();
     if (EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_TYPE, referencedType)) {
       List<EObject> referencedObjects = EcoreUtil2.getAllReferencedObjects(referencer, reference);
       if (referencedObjects.size() > 0) operationCanceledManager.checkCanceled(cancelIndicator);
       for (EObject referencedObject : referencedObjects) {
         EObject resolvedReferencedObject = EcoreUtil.resolve(referencedObject, referencer);
         if (resolvedReferencedObject != null && !resolvedReferencedObject.eIsProxy()) {
           highlightReferenceJvmType(acceptor, referencer, reference, resolvedReferencedObject);
         }
       }
     }
   }
 }
  /**
   * Returns a list that holds the opposite elements of the given reference for the given owner. The
   * opposite elements are those of type E that have the reference to owner.
   *
   * <p>The collection corresponding to opposite in the following picture is returned, for given
   * owner and reference.
   *
   * <pre>
   *    <b>opposite</b>            reference
   *  E ----------------------------- owner
   *  </pre>
   *
   * reference has to be a key of the map observedRefToOpposite.
   *
   * @param <E>
   * @param <E> The type of the elements in the collection.
   * @param dataClass The class of the elements in the collection.
   * @param owner The object whose list is retrieved.
   * @param reference The reference whose opposite reference is retrieved.
   * @return The opposite of reference for owner.
   */
  public <E> List<E> getOppositeList(
      Class<E> dataClass, InternalEObject owner, EReference reference) {
    EReference opposite = observedRefToOpposite.get(reference);
    if (opposite == null)
      throw new IllegalArgumentException(
          "This reference is not observed by this adapter: " + reference.toString());

    EObjectEList<E> result = new EObjectEList<E>(dataClass, owner, opposite.getFeatureID());

    for (Setting cur : getNonNavigableInverseReferences(owner, false)) {
      if (cur.getEStructuralFeature().equals(reference))
        result.add(dataClass.cast(cur.getEObject()));
    }

    return result;
  }
  private void adjustPersistentOppositeReference(
      InternalCDOObject cdoObject, EObject oppositeObject, EReference oppositeReference) {
    InternalCDOObject oppositeCDOObject = (InternalCDOObject) CDOUtil.getCDOObject(oppositeObject);
    if (oppositeCDOObject != null) {
      InternalCDOView view = oppositeCDOObject.cdoView();
      if (view != null) {
        CDOStore store = viewAndState.view.getStore();
        if (store != null) {
          if (oppositeReference.isMany()) {
            EObject eObject = oppositeCDOObject.cdoInternalInstance();

            @SuppressWarnings("unchecked")
            EList<Object> list = (EList<Object>) eObject.eGet(oppositeReference);
            int index = list.indexOf(instance);

            if (index != EStore.NO_INDEX && !store.isEmpty(oppositeCDOObject, oppositeReference)) {
              store.set(oppositeCDOObject, oppositeReference, index, cdoObject);
            }
          } else {
            store.set(oppositeCDOObject, oppositeReference, 0, cdoObject);
          }
        }
      }
    }
  }
Example #30
0
 /**
  * Converts the value of an EReference with isMany==false, the value is converted to a Object and
  * set in the correct feature in the model managed object.
  *
  * @param eObject the eObject from which the value is read
  * @param modelObject the Object in which the value is to be set
  * @param eReference the eReference which is converted
  */
 protected void convertSingleEReference(
     final EObject eObject, final ModelObject<?> modelObject, final EReference eReference) {
   // bidirectional one-to-many are always set from the many side to preserve the order
   final EObject value = (EObject) eObject.eGet(eReference);
   if (!eReference.isMany()
       && value != null
       && eReference.getEOpposite() != null
       && eReference.getEOpposite().isMany()) {
     return;
   }
   if (value == null) {
     modelObject.eSet(eReference, null);
   } else {
     modelObject.eSet(eReference, createTarget(value));
   }
 }