Java EObjectDescription类代码示例

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
/**
 * Returns description for given element, name is assumed to consist of a single segment containing the simple name
 * of the member. If no subScope contains a member with given name, null is returned. In other error cases (no or
 * wrong access, mixed types etc.), {@link IEObjectDescriptionWithError}, and in particular
 * {@link UnionMemberDescriptionWithError}, will be returned.
 */
@Override
protected IEObjectDescription getSingleLocalElementByName(QualifiedName qualifiedName) {
	String name = qualifiedName.getLastSegment();
	TMember member = getOrCreateComposedMember(name);
	if (member == null) { // no such member, no need for "merging" descriptions, there won't be any
		return null;
	}

	if (isErrorPlaceholder(member)) {
		return createComposedMemberDescriptionWithErrors(EObjectDescription.create(member.getName(), member));
	}

	IEObjectDescription description = getCheckedDescription(name, member);

	return description;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
protected IEObjectDescription getCheckedDescription(String name, TMember member) {
	IEObjectDescription description = EObjectDescription.create(member.getName(), member);

	QualifiedName qn = QualifiedName.create(name);
	boolean allDescrWithError = true;
	for (IScope currSubScope : subScopes) {
		IEObjectDescription subDescription = currSubScope.getSingleElement(qn);
		boolean descrWithError = subDescription == null || subDescription instanceof IEObjectDescriptionWithError;
		allDescrWithError &= descrWithError;
	}
	if (allDescrWithError) {
		return createComposedMemberDescriptionWithErrors(description);
	}

	return description;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
protected IEObjectDescription getCheckedDescription(String name, TMember member) {
	IEObjectDescription description = EObjectDescription.create(member.getName(), member);

	QualifiedName qn = QualifiedName.create(name);
	for (IScope currSubScope : subScopes) {
		IEObjectDescription subDescription = currSubScope.getSingleElement(qn);

		boolean descrWithError = subDescription == null || subDescription instanceof IEObjectDescriptionWithError;
		if (descrWithError) {
			return createComposedMemberDescriptionWithErrors(description);
		}
	}

	return description;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
public ArrayList<IEObjectDescription> getTypes(final Extension ext) {
  ArrayList<IEObjectDescription> _xblockexpression = null;
  {
    ArrayList<IEObjectDescription> res = new ArrayList<IEObjectDescription>();
    EList<DataType> _types = ext.getTypes();
    for (final DataType k : _types) {
      res.add(EObjectDescription.create(QualifiedName.create(k.getName()), k));
    }
    EList<Extension> _import = ext.getImport();
    for (final Extension importExtension : _import) {
      EList<DataType> _types_1 = importExtension.getTypes();
      for (final DataType k_1 : _types_1) {
        res.add(EObjectDescription.create(QualifiedName.create(importExtension.getName(), k_1.getName()), k_1));
      }
    }
    _xblockexpression = res;
  }
  return _xblockexpression;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
public IScope createFeatureCallSerializationScope(EObject context) {
	if (!(context instanceof XAbstractFeatureCall)) {
		return IScope.NULLSCOPE;
	}
	XAbstractFeatureCall call = (XAbstractFeatureCall) context;
	JvmIdentifiableElement feature = call.getFeature();
	// this and super - logical container aware FeatureScopes
	if (feature instanceof JvmType) {
		return getTypeScope(call, (JvmType) feature);
	}
	if (feature instanceof JvmConstructor) {
		return getThisOrSuperScope(call, (JvmConstructor) feature);
	}
	if (feature instanceof JvmExecutable) {
		return getExecutableScope(call, feature);
	}
	if (feature instanceof JvmFormalParameter || feature instanceof JvmField || feature instanceof XVariableDeclaration || feature instanceof XSwitchExpression) {
		return new SingletonScope(EObjectDescription.create(feature.getSimpleName(), feature), IScope.NULLSCOPE);
	}
	return IScope.NULLSCOPE;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
protected IScope doGetTypeScope(XMemberFeatureCall call, JvmType type) {
	if (call.isPackageFragment()) {
		if (type instanceof JvmDeclaredType) {
			int segmentIndex = countSegments(call);
			String packageName = ((JvmDeclaredType) type).getPackageName();
			List<String> splitted = Strings.split(packageName, '.');
			String segment = splitted.get(segmentIndex);
			return new SingletonScope(EObjectDescription.create(segment, type), IScope.NULLSCOPE);
		}
		return IScope.NULLSCOPE;
	} else {
		if (type instanceof JvmDeclaredType && ((JvmDeclaredType) type).getDeclaringType() == null) {
			return new SingletonScope(EObjectDescription.create(type.getSimpleName(), type), IScope.NULLSCOPE);
		} else {
			XAbstractFeatureCall target = (XAbstractFeatureCall) call.getMemberCallTarget();
			if (target.isPackageFragment()) {
				String qualifiedName = type.getQualifiedName();
				int dot = qualifiedName.lastIndexOf('.');
				String simpleName = qualifiedName.substring(dot + 1);
				return new SingletonScope(EObjectDescription.create(simpleName, type), IScope.NULLSCOPE);
			} else {
				return new SingletonScope(EObjectDescription.create(type.getSimpleName(), type), IScope.NULLSCOPE);	
			}
		}
	}
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
protected List<IEObjectDescription> getLocalElementsByName(QualifiedName name) {
	XAbstractFeatureCall featureCall = getFeatureCall();
	if (featureCall.isExplicitOperationCallOrBuilderSyntax())
		return Collections.emptyList();
	if (rawEnclosingType instanceof JvmDeclaredType && name.getSegmentCount() == 1) {
		String singleSegment = name.getFirstSegment();
		List<String> lookup = Collections.singletonList(singleSegment);
		if (singleSegment.indexOf('$') != -1) {
			lookup = Strings.split(singleSegment, '$');
		}
		JvmType result = findNestedType((JvmDeclaredType)rawEnclosingType, lookup.iterator());
		if (result != null) {
			IEObjectDescription description = EObjectDescription.create(name, result);
			return Collections.<IEObjectDescription>singletonList(new TypeLiteralDescription(description, enclosingType, isVisible(result)));
		}
	}
	return Collections.emptyList();
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
public IScope createTypeScope(EObject context, EReference reference) {
	if (context.eClass() == TypesPackage.Literals.JVM_INNER_TYPE_REFERENCE) {
		JvmInnerTypeReference casted = (JvmInnerTypeReference) context;
		JvmParameterizedTypeReference outerType = casted.getOuter();
		JvmType outerRawType = outerType.getType();
		if (outerRawType instanceof JvmDeclaredType) {
			Iterable<JvmDeclaredType> nestedTypes = ((JvmDeclaredType) outerRawType).getAllNestedTypes();
			List<IEObjectDescription> descriptions = Lists.newArrayList();
			for(JvmDeclaredType nestedType: nestedTypes) {
				descriptions.add(EObjectDescription.create(nestedType.getSimpleName(), nestedType));
			}
			return new SimpleScope(descriptions);
		}
		return IScope.NULLSCOPE;
	} else {
		final IScope delegateScope = getDelegate().getScope(context, reference);
		return delegateScope;
	}
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
public IScope getScope(EObject context, EReference reference) {
	if (reference == XAnnotationsPackage.Literals.XANNOTATION_ELEMENT_VALUE_PAIR__ELEMENT) {
		XAnnotation annotation = EcoreUtil2.getContainerOfType(context, XAnnotation.class);
		JvmType annotationType = annotation.getAnnotationType();
		if (annotationType == null || annotationType.eIsProxy() || !(annotationType instanceof JvmAnnotationType)) {
			return IScope.NULLSCOPE;
		}
		Iterable<JvmOperation> operations = ((JvmAnnotationType) annotationType).getDeclaredOperations();
		Iterable<IEObjectDescription> descriptions = transform(operations, new Function<JvmOperation, IEObjectDescription>() {
			@Override
			public IEObjectDescription apply(JvmOperation from) {
				return EObjectDescription.create(QualifiedName.create(from.getSimpleName()), from);
			}
		});
		return MapBasedScope.createScope(IScope.NULLSCOPE, descriptions);
	}
	return super.getScope(context, reference);
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
protected boolean createEObjectDescriptions(IQualifiedNameProvider qualifiedNameProvider, boolean isNsURI,
		EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
	try {
		QualifiedName qualifiedName = qualifiedNameProvider.getFullyQualifiedName(eObject);
		if (qualifiedName != null) {
			Map<String, String> userData = Maps.newHashMapWithExpectedSize(1);
			userData.put(NS_URI_INDEX_ENTRY, Boolean.toString(isNsURI));
			IEObjectDescription description = EObjectDescription.create(qualifiedName, eObject, userData);
			acceptor.accept(description);
			return true;
		}
	} catch (Exception exc) {
		LOG.error(exc.getMessage(), exc);
	}
	return false;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
public Iterable<IEObjectDescription> getElements(EObject object) {
	if (object instanceof JvmConstructor) {
		JvmConstructor constructor = ((JvmConstructor) object);
		String qualifiedNameWithDots = constructor.getQualifiedName('.');
		String qualifiedNameWithDollar = constructor.getQualifiedName();
		if (qualifiedNameWithDollar.equals(qualifiedNameWithDots)) {
			final Set<IEObjectDescription> result = singleton(
					EObjectDescription.create(getQualifiedNameConverter().toQualifiedName(qualifiedNameWithDots), object));
			return result;
		} else {
			return Arrays.asList(
					EObjectDescription.create(getQualifiedNameConverter().toQualifiedName(qualifiedNameWithDots), object),
					EObjectDescription.create(getQualifiedNameConverter().toQualifiedName(qualifiedNameWithDollar), object));
		}
	}
	return emptySet();
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
public Iterable<IEObjectDescription> getElements(EObject object) {
	if (object instanceof JvmIdentifiableElement) {
		JvmIdentifiableElement identifiable = ((JvmIdentifiableElement) object);
		String qualifiedNameWithDots = identifiable.getQualifiedName('.');
		String qualifiedNameWithDollar = identifiable.getQualifiedName();
		if (qualifiedNameWithDollar.equals(qualifiedNameWithDots)) {
			final Set<IEObjectDescription> result = singleton(
					EObjectDescription.create(qualifiedNameConverter.toQualifiedName(qualifiedNameWithDots), object));
			return filterResult(result);
		} else {
			return filterResult(Arrays.asList(
					EObjectDescription.create(qualifiedNameConverter.toQualifiedName(qualifiedNameWithDots), object),
					EObjectDescription.create(qualifiedNameConverter.toQualifiedName(qualifiedNameWithDollar), object)));
		}
	}
	return emptySet();
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Override
public Iterable<IEObjectDescription> getElements(EObject object) {
	if (object instanceof AbstractRule) {
		Grammar grammar = GrammarUtil.getGrammar(context);
		AbstractRule rule = (AbstractRule) object;
		if (GrammarUtil.getGrammar(rule) == grammar) {
			return Lists.newArrayList(
					EObjectDescription.create(GrammarUtil.getSimpleName(grammar) + "." + rule.getName(), rule),
					EObjectDescription.create(grammar.getName() + "." + rule.getName(), rule));
		}
		List<IEObjectDescription> result = Lists.newArrayList(
				EObjectDescription.create(SUPER + "." + rule.getName(), rule),
				EObjectDescription.create(GrammarUtil.getSimpleName(grammar) + "." + rule.getName(), rule),
				EObjectDescription.create(grammar.getName() + "." + rule.getName(), rule));
		AbstractRule contextRule = GrammarUtil.containingRule(context);
		if (contextRule != null && contextRule.getName().equals(rule.getName())) {
			result.add(0, EObjectDescription.create(SUPER, rule));
		}
		return result;
	}
	return Collections.emptyList();
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
protected IScope createScope(final Grammar grammar, EClass type, IScope current) {
	if (EcorePackage.Literals.EPACKAGE == type) {
		return createEPackageScope(grammar);
	} else if (AbstractMetamodelDeclaration.class.isAssignableFrom(type.getInstanceClass())) {
		return new SimpleScope(IScope.NULLSCOPE,Iterables.transform(grammar.getMetamodelDeclarations(),
						new Function<AbstractMetamodelDeclaration,IEObjectDescription>(){
							@Override
							public IEObjectDescription apply(AbstractMetamodelDeclaration from) {
								String name = from.getAlias() != null ? from.getAlias() : "";
								return EObjectDescription.create(QualifiedName.create(name), from);
							}
						}));
	}
	final List<Grammar> allGrammars = getAllGrammars(grammar);
	for (int i = allGrammars.size() - 1; i >= 0; i--) {
		current = doCreateScope(allGrammars.get(i), type, current);
	}
	return current;
}
 

import org.eclipse.xtext.resource.EObjectDescription; //导入依赖的package包/类
@Test public void testHasChanges_DifferentTypes() throws Exception {
	TestResDesc resourceDesc = new TestResDesc();
	resourceDesc.imported.add(FOO);
	resourceDesc.exported.add(EObjectDescription.create(BAR, EcorePackage.Literals.EANNOTATION, Collections.singletonMap("foo", "bar")));
	
	TestResDesc resourceDesc2 = new TestResDesc();
	resourceDesc2.imported.add(FOO);
	resourceDesc2.exported.add(new EObjectDescription(BAR, EcorePackage.Literals.EANNOTATION__CONTENTS, Collections.singletonMap("foo", "bar")){
		@Override
		public URI getEObjectURI() {
			return EcoreUtil.getURI(EcorePackage.Literals.EANNOTATION);
		}
	}
	);
	
	assertTrue(new DefaultResourceDescriptionDelta(resourceDesc, resourceDesc2).haveEObjectDescriptionsChanged());
}