Java EcoreUtil2.isAssignableFrom方法代码示例

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
/**
 * @Nullable
 */
protected String getTypeName(final EClass c, final EStructuralFeature referingFeature) {
  if ((referingFeature == XAnnotationsPackage.Literals.XANNOTATION__ANNOTATION_TYPE)) {
    return " to an annotation type";
  }
  if ((c == TypesPackage.Literals.JVM_ENUMERATION_TYPE)) {
    return " to an enum type";
  }
  boolean _isAssignableFrom = EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_TYPE, c);
  if (_isAssignableFrom) {
    return " to a type";
  }
  if ((c == TypesPackage.Literals.JVM_OPERATION)) {
    return " to an operation";
  }
  return "";
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
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);
				}
			}
		}
	}
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
public List<CrossReference> findCrossReferences(EClassifier... targetEClassifiers) {
	Set<EClassifier> classifiers = new HashSet<EClassifier>(Arrays.asList(targetEClassifiers));
	Collection<EClass> classes = Lists.newArrayList(Iterables.filter(classifiers, EClass.class));
	ArrayList<CrossReference> r = new ArrayList<CrossReference>();
	for (AbstractRule ar : getRules()) {
		TreeIterator<EObject> i = ar.eAllContents();
		while (i.hasNext()) {
			EObject o = i.next();
			if (o instanceof CrossReference) {
				CrossReference c = (CrossReference) o;
				if (classifiers.contains(c.getType().getClassifier()))
					r.add(c);
				else if (c.getType().getClassifier() instanceof EClass)
					for (EClass cls : classes)
						if (EcoreUtil2.isAssignableFrom(cls,(EClass) c.getType().getClassifier())) {
							r.add(c);
							break;
						}
				i.prune();
			}
		}
	}
	return r;

}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
/**
 * @param eReferenceType
 *            the type of the reference that is inspected.
 * @return <code>true</code> if this set contains a subtype of the given eReferenceType.
 */
public boolean isEReferenceTypeApplicable(EClass eReferenceType) {
	if (applicableTypes.isEmpty())
		return true;
	for (EClass applicableType : applicableTypes) {
		if (EcoreUtil2.isAssignableFrom(eReferenceType, applicableType)) {
			return true;
		}
	}
	return false;
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
@Override
public IScope getScope(Resource resource, EReference reference, Predicate<IEObjectDescription> filter) {
	EClass referenceType = getEReferenceType(resource, reference);
	if (EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_TYPE, referenceType)) {
		return typeScopeProvider.getScope(resource, reference, filter);
	}
	if (EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_CONSTRUCTOR, referenceType)) {
		return typeScopeProvider.getScope(resource, reference, filter);
	}
	return super.getScope(resource, reference, filter);
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
protected Set<AbstractElement> findValidAssignmentsForCrossRef(EObject semanticObj,
		Iterable<AbstractElement> assignedElements, EObject value, INode node) {
	Set<AbstractElement> result = Sets.newLinkedHashSet();
	for (AbstractElement ass : assignedElements) {
		CrossReference crossref = GrammarUtil.containingCrossReference(ass);
		EReference eref = GrammarUtil.getReference(crossref, semanticObj.eClass());
		if (EcoreUtil2.isAssignableFrom(eref.getEReferenceType(), value.eClass())
				&& crossRefSerializer.isValid(semanticObj, crossref, value, node, null))
			result.add(ass);
	}
	return result;
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
private boolean isInstantiatableSubType(EClass c, EClass superType) {
	return !c.isAbstract() && !c.isInterface() && EcoreUtil2.isAssignableFrom(superType, c);
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
private IEObjectDescription resolve(IEObjectDescription original) {
	if (original != null && original.getEObjectOrProxy().eIsProxy()
			&& EcoreUtil2.isAssignableFrom(type, original.getEClass())) {
		final URI objectURI = original.getEObjectURI();
		final URI resourceURI = objectURI.trimFragment();
		Resource resource = resourceSet.getResource(resourceURI, false);
		if (resource != null && resource.isLoaded()) {
			return original;
		}
		final boolean mustLoadFromSource = canLoadFromDescriptionHelper.mustLoadFromSource(resourceURI,
				resourceSet);
		resource = resourceSet.getResource(resourceURI, mustLoadFromSource);
		if (resource != null && resource.isLoaded()) {
			return original;
		}
		if (mustLoadFromSource) {
			// error case: forced loading failed
			// --> still avoid loading from index; instead simply return 'original' as in other error cases
			return original;
		}
		if (resource == null) {
			resource = resourceSet.createResource(resourceURI);
		}
		if (resource instanceof N4JSResource) {
			if (resource.getContents().isEmpty()) {
				N4JSResource casted = (N4JSResource) resource;
				IResourceDescription resourceDescription = container.getResourceDescription(resourceURI);
				if (resourceDescription != null) {
					if (casted.isLoaded()) {
						// LiveShadowingResourceDescriptions (part of Xtext's rename refactoring)
						// will load that stuff on #getResourceDescription
						return original;
					}
					try {
						if (!casted.loadFromDescription(resourceDescription)) {
							return original;
						}
					} catch (Exception e) {
						casted.unload();
						return original;
					}
				} else {
					return original;
				}
			}
			// resolveProxy is implemented recursively thus we have to avoid
			// that here by decorating the
			// description and return the resolved instance instead
			EObject resolved = resolveObject(objectURI, resource);
			if (resolved == null) {
				return original;
			}
			return new ResolvedDescription(resolved, original);
		}
	}
	return original;
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
/**
 * @since 2.4
 */
protected EObject getEObject(String uriFragment, Triple<EObject, EReference, INode> triple) throws AssertionError {
	if (!resolving.add(triple))
		return handleCyclicResolution(triple);
	try {
		Set<String> unresolveableProxies = getUnresolvableURIFragments();
		if (unresolveableProxies.contains(uriFragment))
			return null;
		EReference reference = triple.getSecond();
		try {
			List<EObject> linkedObjects = getLinkingService().getLinkedObjects(
					triple.getFirst(), 
					reference,
					triple.getThird());

			if (linkedObjects.isEmpty()) {
				if (isUnresolveableProxyCacheable(triple))
					unresolveableProxies.add(uriFragment);
				createAndAddDiagnostic(triple);
				return null;
			}
			if (linkedObjects.size() > 1)
				throw new IllegalStateException("linkingService returned more than one object for fragment "
						+ uriFragment);
			EObject result = linkedObjects.get(0);
			if (!EcoreUtil2.isAssignableFrom(reference.getEReferenceType(), result.eClass())) {
				log.error("An element of type " + result.getClass().getName()
						+ " is not assignable to the reference " + reference.getEContainingClass().getName()
						+ "." + reference.getName());
				if (isUnresolveableProxyCacheable(triple))
					unresolveableProxies.add(uriFragment);
				createAndAddDiagnostic(triple);
				return null;
			}
			// remove previously added error markers, since everything should be fine now
			unresolveableProxies.remove(uriFragment);
			removeDiagnostic(triple);
			return result;
		} catch (CyclicLinkingException e) {
			if (e.triple.equals(triple)) {
				log.error(e.getMessage(), e);
				if (isUnresolveableProxyCacheable(triple))
					unresolveableProxies.add(uriFragment);
				createAndAddDiagnostic(triple);
				return null;
			} else {
				throw e;
			}
		}
	} catch (IllegalNodeException ex) {
		createAndAddDiagnostic(triple, ex);
		return null;
	} finally {
		resolving.remove(triple);
	}
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
protected boolean isAssignable(final EClass superType, final EClassifier type) {
  if ((type instanceof EClass)) {
    return EcoreUtil2.isAssignableFrom(superType, ((EClass)type));
  }
  return false;
}
 

import org.eclipse.xtext.EcoreUtil2; //导入方法依赖的package包/类
/**
 * Determine whether a type is an instantiable subtype of another type.
 *
 * @param c
 *          EClass to check.
 * @param superType
 *          of which c should be a subtype.
 * @return {@code true}, if c is instantiable and assignment-compatible with {@code superType}.
 */
private static boolean isInstantiatableSubType(final EClass c, final EClass superType) {
  return !c.isAbstract() && !c.isInterface() && EcoreUtil2.isAssignableFrom(superType, c);
}