directSubClasses.put(eClass.getName(), new HashSet<EClass>()); for (EClass superClass : eClass.getEAllSuperTypes()) { if (!allSubClasses.containsKey(superClass.getName())) { allSubClasses.put(superClass.getName(), new HashSet<EClass>());
public Collection<? extends EClassifier> getAllSupertypes(EClassifier classifier) { if (classifier instanceof EClass) { return ((EClass) classifier).getEAllSuperTypes(); } return Collections.emptySet(); }
public static List<EClass> getCompatibleTypesOf(EClass eClass) { List<EClass> ca = new ArrayList<EClass>(eClass.getEAllSuperTypes()); ca.add(eClass); return ca; }
EClassifier eType = schemaPack.getEClassifier(((DefinedType) attributeName.getType()).getName()); boolean found = false; for (EClass eSuperType : eClass.getEAllSuperTypes()) { if (eSuperType.getEStructuralFeature(attributeName.getName()) != null) { found = true;
/** * Determines if the class or interface represented by this Class object is either * the same as, or is a super class or super interface of, the class or interface * represented by the specified someClass parameter. Semantics are the same as * java.lang.Class#isAssignableFrom */ public boolean isSuperTypeOf(EClass someClass) { return someClass == this || someClass.getEAllSuperTypes().contains(this); }
/** * Determines if the class or interface represented by this Class object is either * the same as, or is a super class or super interface of, the class or interface * represented by the specified someClass parameter. Semantics are the same as * java.lang.Class#isAssignableFrom */ public boolean isSuperTypeOf(EClass someClass) { return someClass == this || someClass.getEAllSuperTypes().contains(this); }
public int compare(EClass classA, EClass classB) { if (classA.getEAllSuperTypes().contains(classB)) return -1; if (classB.getEAllSuperTypes().contains(classA)) return 1; return 0; } }
private static boolean isLooslyCompatibleWith(EClass classA, EClass classB) { return classA.equals(classB) || classA.getEAllSuperTypes().contains(classB) || classB.getEAllSuperTypes().contains(classA); }
public <T extends EObject> Iterable<? extends Initializer<? super T>> getInitializers(EClass eclass, boolean inherit) { Iterable<? extends Initializer<? super T>> result = initializersFor(eclass); if (inherit) { // copy, then add List<Initializer<? super T>> listResult = new java.util.ArrayList<Initializer<? super T>>(); for (Initializer<? super T> next : result) { listResult.add(next); } for (EClass super_ : eclass.getEAllSuperTypes()) { for (Initializer<? super T> next : initializersFor(super_)) { listResult.add(next); } } result = listResult; } return result; }
public List<GenClass> getAllBaseGenClasses() { if (allBaseGenClasses == null) { allBaseGenClasses = collectGenClasses(getEcoreClass().getEAllSuperTypes(), null); } return allBaseGenClasses; }
@Override protected void setTarget(EObject target) { for (EClass c : target.eClass().getEAllSuperTypes()) { put(c, target); } put(target.eClass(), target); super.setTarget(target); }
@Override protected void unsetTarget(EObject target) { for (EClass c : target.eClass().getEAllSuperTypes()) { remove(c, target); } remove(target.eClass(), target); super.unsetTarget(target); }
public EClass getXSIType(Element element) { EClass result = null; int last = 0; NodeList nodeList = element.getChildNodes(); EClass type = getType(element); for (int i = 0; i < nodeList.getLength(); i++) { if (nodeList.item(i) instanceof Element) { Element e = (Element) nodeList.item(i); if ("templateId".equals(e.getLocalName())) { EClass eClass = getEClass(e.getAttributeNS(null, "root"), element); if ((eClass != null) && !eClass.isAbstract() && conformsTo(eClass, type) && (eClass.getEAllSuperTypes().size() > last)) { result = eClass; last = eClass.getEAllSuperTypes().size(); } } } } return result; }
private int getRarity(EClassTransitiveInstancesKey key) { return key.getEmfKey().getEAllSuperTypes().size() + (EOBJECT_SCOPED_KEY.equals(key) ? 0 : 1); }
private boolean anySuperTypeContainsSemanticallyEqualFeature(EClassInfo classInfo, EStructuralFeature feature) { Collection<EStructuralFeature> allSupertypesFeatures = Sets.newLinkedHashSet(); for (EClass superType : classInfo.getEClass().getEAllSuperTypes()) allSupertypesFeatures.addAll(superType.getEAllStructuralFeatures()); return classInfo.containsSemanticallyEqualFeature(allSupertypesFeatures, feature) == FindResult.FeatureExists; }
@Override public Collection<?> getChoiceOfValues(Object object) { EClass eClass = (EClass)object; // Filter out classes that aren't permitted. // Collection<?> result = super.getChoiceOfValues(object); result.removeAll(EcorePackage.eINSTANCE.getEClassifiers()); for (Iterator<?> i = result.iterator(); i.hasNext(); ) { EClass otherEClass = (EClass)i.next(); if (otherEClass == eClass || otherEClass.getEAllSuperTypes().contains(eClass)) { i.remove(); } } return result; }
public List<GenClass> getAllBaseGenClasses() { return collectGenClasses(getEcoreClass().getEAllSuperTypes(), null); }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated NOT */ private static boolean isSuperType(EClass type, EClass candidate) { /* type.isSuperTypeOf() doesn't seem to work - it relies * on == rather than .equals */ if (type == null || candidate == null) return false; if (equals(type, candidate)) return true; for (EClass supertypeOfCandidate : candidate.getEAllSuperTypes()) { if (equals(type, supertypeOfCandidate)) return true; } return false; }
@SuppressWarnings("null") @Override public void bindWidget(@NonNull M me, @NonNull W widget) { widget.setDomElement(me); widget.addStyleClasses(this.modelStylingService.getStyles(me)); EObject eo = (EObject) me; widget.addStyleClasses("M" + eo.eClass().getName()); //$NON-NLS-1$ for (EClass e : eo.eClass().getEAllSuperTypes()) { widget.addStyleClasses("M" + e.getName()); //$NON-NLS-1$ } String elementId = me.getElementId(); if (elementId != null) { widget.setStyleId(Util.toCSSId(elementId)); } me.setWidget(widget); }
protected void initBases() { // Go through class super types to catch any from other packages for (GenClass genClass : getGenClasses()) { if (genClass.isEObject()) continue; for (EClass base : genClass.getEcoreClass().getEAllSuperTypes()) { GenClass baseGenClass = findGenClass(base); if (baseGenClass != null && !baseGenClass.isEObject() && add(baseGenClass)) { allGenClasses.add(baseGenClass); if (baseGenClass.getGenPackage() != GenPackageImpl.this) { allBaseGenPackages.add(baseGenClass.getGenPackage()); } } } } }