@Override protected boolean isCompatibleMetaclass(Object containerElement, Object metaclass) { Element semanticElement = UMLUtil.resolveUMLElement(containerElement); if (semanticElement == null) { return false; } if (metaclass instanceof Stereotype) { Stereotype stereotype = (Stereotype) metaclass; boolean res = semanticElement.getAppliedStereotype(stereotype.getQualifiedName()) != null; if (!res) { EClass definition = stereotype.getDefinition(); for (EObject e : semanticElement.getStereotypeApplications()) { EClass c = e.eClass(); if (definition != null && definition.isSuperTypeOf(c)) { res = true; break; } } } return res; } // TODO : We should use super.isCompatibleMetaclass(), but the super-implementation // may not be compatible with our implementation of getAdaptedValue() if (metaclass instanceof EClassifier) { return ((EClassifier) metaclass).isInstance(semanticElement); } return false; }
@Override protected List<? extends IRenameElementContext> createRenameElementContexts(Object element) { if (element instanceof IJavaElement) { IJavaElement javaElement = (IJavaElement) element; EClass expectedJvmType = getExpectedJvmType(javaElement); if (expectedJvmType != null) { IJavaProject javaProject = javaElement.getJavaProject(); IProject project = javaProject.getProject(); ResourceSet resourceSet = resourceSetProvider.get(project); EObject directJvmElement = jvmElementFinder.getCorrespondingJvmElement(javaElement, resourceSet); if (directJvmElement != null && expectedJvmType.isSuperTypeOf(directJvmElement.eClass())) { EObject indexedJvmElement = jvmElementFinder.findJvmElementDeclarationInIndex(directJvmElement, project); if (indexedJvmElement != null) // jvmElement is indexed, thus contained in an XtextResurce and likely inferred from // some Xtext-based elements return getContextFactory(indexedJvmElement) .createJdtParticipantXtextSourceContexts(indexedJvmElement); else if (directJvmElement instanceof JvmMember) // jvmElement is only cross referenced by Xtext-based elements return createJdtRenameParticipantContext((JvmMember) directJvmElement, javaElement); } } } return null; }
public static Collection<EClass> getSubtypesOf(Collection<EClass> eClasses, EClass superType) { if (superType == null) { return eClasses; } for (Iterator<EClass> it = eClasses.iterator(); it.hasNext(); ) { EClass nextEClass = it.next(); if (nextEClass != null && !superType.isSuperTypeOf(nextEClass)) { it.remove(); } } return eClasses; }
/** * Retrieves all EClasses from <code>allEClasses</code> that can possibly be referenced by <code> * reference</code> and returns them as a list. * * @param reference the EReference to get EClasses for * @param allEClasses set of all possible EClasses * @return list of all EClasses that can be referenced by <code>reference</code> */ public static Set<EClass> getReferenceClasses(EReference reference, Set<EClass> allEClasses) { Set<EClass> result = new LinkedHashSet<EClass>(); EClass referenceType = reference.getEReferenceType(); // 'referenceType: EObject' allows all kinds of EObjects if (referenceType.equals(EcorePackage.eINSTANCE.getEObject())) { return allEClasses; } for (EClass eClass : allEClasses) { // can eClass be referenced by reference if (referenceType.equals(eClass) || referenceType.isSuperTypeOf(eClass)) { result.add(eClass); } } return result; }
public static List<EClass> getSubClasses(EClass parentClass) { List<EClass> classList = new ArrayList<EClass>(); EList<EClassifier> classifiers = Bpmn2Package.eINSTANCE.getEClassifiers(); for (EClassifier classifier : classifiers) { if (classifier instanceof EClass) { EClass clazz = (EClass) classifier; clazz.getEAllSuperTypes().contains(parentClass); if (parentClass.isSuperTypeOf(clazz) && !clazz.isAbstract()) { classList.add(clazz); } } } return classList; }
/** * Returns all containing references where <code>parentClass</code> is the container and <code> * childClass</code> the containment. * * @param childClass the EClass which shall be contained * @param parentClass the EClass to get containment references from * @return all possible container-references as a set */ public static Set<EReference> getAllPossibleContainingReferences( EClass childClass, EClass parentClass) { List<EReference> allReferences = parentClass.getEAllContainments(); Set<EReference> result = new LinkedHashSet<EReference>(); for (EReference reference : allReferences) { EClass referenceType = reference.getEReferenceType(); if (referenceType == null) { continue; } // is the reference type a perfect match? if (referenceType.equals(childClass)) { result.add(reference); // is the reference type either EObject or a super type? } else if (referenceType.equals(EcorePackage.eINSTANCE.getEObject()) || referenceType.isSuperTypeOf(childClass)) { result.add(reference); } } return result; }
/** * Returns all subclasses of an EClass, excluding abstract classes and interfaces. * * @param eClass the EClass to get subclasses for * @return all subclasses of <code>eClass</code> */ public static List<EClass> getAllSubEClasses(EClass eClass) { if (eClassToSubEClasses.containsKey(eClass)) { return eClassToSubEClasses.get(eClass); } if (eClass == null) { eClassToSubEClasses.put(eClass, new LinkedList<EClass>()); return eClassToSubEClasses.get(eClass); } List<EClass> allEClasses = getAllEClasses(); List<EClass> result = new LinkedList<EClass>(); for (EClass possibleSubClass : allEClasses) { // is the EClass really a subClass, while not being abstract or an interface? if (eClass.isSuperTypeOf(possibleSubClass) && canHaveInstance(possibleSubClass)) { result.add(possibleSubClass); } } // save the result for upcoming method calls eClassToSubEClasses.put(eClass, result); return result; }
protected void cacheMetaParameters(EObject scopeDetermeningObject) { // System.err.println("Computing meta cache"); metaCache = Maps.newHashMap(); Resource scopeDetermeningResource = scopeDetermeningObject.eResource(); IResourceDescriptions descriptionIndex = indexProvider.getResourceDescriptions(scopeDetermeningResource); IResourceDescription descr = descriptionIndex.getResourceDescription(scopeDetermeningResource.getURI()); if (descr == null) return; // give up - some sort of clean build EClass wantedType = PPTPPackage.Literals.TYPE_ARGUMENT; for (IContainer visibleContainer : manager.getVisibleContainers(descr, descriptionIndex)) { for (IEObjectDescription objDesc : visibleContainer.getExportedObjects()) { QualifiedName q = objDesc.getQualifiedName(); if ("Type".equals(q.getFirstSegment())) { if (wantedType == objDesc.getEClass() || wantedType.isSuperTypeOf(objDesc.getEClass())) metaCache.put(q.getLastSegment(), objDesc); } } } }
/** * Return all elements in a flat list which have the type given in <code>types</code>. The entire * model tree is searched, i.e. it is a deep search. * * @param elements A set of elements. * @param types The types which should be returned. * @param includeSubtypes If <code>true</code>, then also subtypes of the given types are included * in the result. * @return A list of all elements which are of a type that is given in <code>types</code>. */ public static List<EObject> collectTypedElements( final List<? extends EObject> elements, final Set<EClass> types, boolean includeSubtypes) { final List<EObject> result = new ArrayList<EObject>(); final Queue<EObject> queue = new LinkedList<EObject>(); queue.addAll(elements); while (!queue.isEmpty()) { final EObject element = queue.poll(); if (includeSubtypes) { for (EClass eClass : types) { if (eClass.isSuperTypeOf(element.eClass())) { result.add(element); break; } } } else { if (types.contains(element.eClass())) result.add(element); } queue.addAll(element.eContents()); } return result; }
/** * This method has been used to write in the console the text for the 3 managed EClass. * * @param eClass the e class */ private static final void writeAllSubTypeMethodInConsole(final EClass eClass) { List<EClass> subType = new ArrayList<EClass>(); for (EClassifier current : UMLPackage.eINSTANCE.getEClassifiers()) { if (current instanceof EClass) { if (eClass.isSuperTypeOf((EClass) current)) { if (!((EClass) current).isAbstract() && !((EClass) current).isInterface()) { subType.add((EClass) current); } } } } for (EClass current : subType) { String name = current.getName(); String methodeName = "notify" + name + "Changed"; // $NON-NLS-1$ //$NON-NLS-2$ System.out.println( "@Override\n protected void " + methodeName + "(Notification notification, EClass eClass){"); //$NON-NLS-1$ //$NON-NLS-2$ System.out.println( "super." + methodeName + "(notification,eClass);"); // $NON-NLS-1$ //$NON-NLS-2$ System.out.println( "switch(notification.getFeatureID(org.eclipse.uml2.uml." + name + ".class)) {\n"); //$NON-NLS-1$ //$NON-NLS-2$ if (eClass == UMLPackage.eINSTANCE.getClassifier()) { System.out.println( "case UMLPackage.CLASSIFIER__GENERALIZATION: \n notifyChanged(notification, eClass, UMLPackage.Literals.CLASS__SUPER_CLASS); \n break; \n case UMLPackage.CLASSIFIER__GENERAL:notifyChanged(notification, eClass, UMLPackage.Literals.CLASSIFIER__GENERALIZATION);\n"); //$NON-NLS-1$ } if (eClass == UMLPackage.eINSTANCE.getStructuredClassifier()) { System.out.println( "case UMLPackage.STRUCTURED_CLASSIFIER__OWNED_ATTRIBUTE: \n notifyChanged(notification, eClass, UMLPackage.Literals.ENCAPSULATED_CLASSIFIER__OWNED_PORT);"); //$NON-NLS-1$ } if (eClass == UMLPackage.eINSTANCE.getPackage()) { System.out.println( "case UMLPackage.PACKAGE__PACKAGED_ELEMENT:\n notifyChanged(notification, eClass, UMLPackage.Literals.PACKAGE__NESTED_PACKAGE);\n notifyChanged(notification, eClass, UMLPackage.Literals.PACKAGE__OWNED_STEREOTYPE); \n notifyChanged(notification, eClass, UMLPackage.Literals.PACKAGE__OWNED_TYPE);\n"); //$NON-NLS-1$ } System.out.println("break; \n default:break;\n break;\n}}"); // $NON-NLS-1$ } }
public static Collection<EClass> filterByFeatureSeqInitializer( Collection<EClass> eClasses, FeatureSeqInitializer featureSeqInitializer) { if (featureSeqInitializer.getCreatingInitializer() != null) { EStructuralFeature feature = featureSeqInitializer.getCreatingInitializer().getFeature(); if (feature != null && feature.getEType() instanceof EClass) { for (Iterator<EClass> it = eClasses.iterator(); it.hasNext(); ) { EClass nextEClass = it.next(); EClass typeEClass = (EClass) feature.getEType(); if (nextEClass == null || nextEClass.isAbstract() || nextEClass.isInterface() || !typeEClass.isSuperTypeOf(nextEClass)) { it.remove(); } } } } else if (featureSeqInitializer.getElementClass() != null) { return Collections.singleton(featureSeqInitializer.getElementClass()); } return eClasses; }
public static Set<EClass> getAllSubClasses( EClass baseClass, boolean includeBaseClass, boolean includeInterfaces, boolean includeAbstracts) { Set<EClass> result = new HashSet<EClass>(); if (includeBaseClass) { includeClass(baseClass, includeInterfaces, includeAbstracts, result); } Set<EPackage> ePackages = getAllPackages(); for (EPackage ePackage : ePackages) { List<EClassifier> classifiers = ePackage.getEClassifiers(); for (EClassifier classifier : classifiers) { if (classifier instanceof EClass && baseClass.isSuperTypeOf((EClass) classifier)) { includeClass(classifier, includeInterfaces, includeAbstracts, result); } } } return result; }
private boolean instance(final EClass valid, final EObject type) { return type.eClass() == valid || valid.isSuperTypeOf(type.eClass()); }