@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;
  }
Пример #2
0
 @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;
 }
Пример #8
0
  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);
        }
      }
    }
  }
Пример #9
0
 /**
  * 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$
    }
  }
Пример #11
0
  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;
  }
Пример #12
0
  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());
 }