Java GrammarUtil.containingAssignment方法代码示例

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected boolean shouldUseParent(ICompositeNode result, int offset, ILeafNode leaf) {
	if (leaf.getTotalEndOffset() == offset) {
		return true;
	}
	if (result.getGrammarElement() instanceof RuleCall) {
		RuleCall rc = (RuleCall) result.getGrammarElement();
		if (!rc.getArguments().isEmpty()) {
			return true;
		}
		Assignment assignment = GrammarUtil.containingAssignment(rc);
		if (assignment != null
				&& (GrammarUtil.isMultipleCardinality(assignment) || (assignment.eContainer() instanceof AbstractElement && GrammarUtil
						.isMultipleCardinality((AbstractElement) assignment.eContainer())))) {
			return true;
		}
	}
	return false;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected ILocationData getLocationOfDefault(XSwitchExpression expression) {
	final ICompositeNode startNode = NodeModelUtils.getNode(expression);
	if (startNode != null) {
		List<INode> resultNodes = Lists.newArrayList();
		boolean defaultSeen = false;
		for (INode child : startNode.getChildren()) {
			if (defaultSeen) {
				resultNodes.add(child);
				if (GrammarUtil.containingAssignment(child.getGrammarElement()) != null) {
					break;
				}
			} else if (child.getGrammarElement() instanceof Keyword && "default".equals(child.getText())) {
				defaultSeen = true;
				resultNodes.add(child);
			}
		}
		return toLocationData(resultNodes);
	}
	return null;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
/**
 * Returns the smallest node that covers all assigned values of the given object. It handles the semantics of {@link Action
 * actions} and {@link RuleCall unassigned rule calls}.
 * 
 * @return the minimal node that covers all assigned values of the given object.
 * @since 2.3
 */
protected ICompositeNode findNodeFor(EObject semanticObject) {
	ICompositeNode result = NodeModelUtils.getNode(semanticObject);
	if (result != null) {
		ICompositeNode node = result;
		while (GrammarUtil.containingAssignment(node.getGrammarElement()) == null && node.getParent() != null && !node.getParent().hasDirectSemanticElement()) {
			ICompositeNode parent = node.getParent();
			if (node.hasSiblings()) {
				for(INode sibling: parent.getChildren()) {
					EObject grammarElement = sibling.getGrammarElement();
					if (grammarElement != null && GrammarUtil.containingAssignment(grammarElement) != null) {
						result = parent;
					}
				}
			}
			node = parent;
		}
	}
	return result;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
/**
 * @return true, if the parent node could contain cross references to the same semantic element as the given node.
 */
protected boolean shouldCheckParentNode(INode node) {
	EObject grammarElement = node.getGrammarElement();
	if (grammarElement instanceof AbstractElement) {
		ICompositeNode parent = node.getParent();
		if (parent != null) {
			if (!parent.hasDirectSemanticElement()) {
				if (isContainedInFragmentRule(grammarElement)) {
					return false;
				}
				Assignment assignment = GrammarUtil.containingAssignment(grammarElement);
				if (assignment == null) {
					return true;
				}
			}
			if (grammarElement instanceof Action) {
				if (isContainedInFragmentRule(grammarElement)) {
					return parent.getGrammarElement() instanceof RuleCall;
				}
			}
		}
	}
	return false;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Override
public EStructuralFeature getContainingFeature() {
	String feature = null;
	if (grammarElement instanceof Action) {
		feature = ((Action) grammarElement).getFeature();
	} else {
		Assignment assignment = GrammarUtil.containingAssignment(getGrammarElement());
		if (assignment != null) {
			feature = assignment.getFeature();
		}
	}
	if (feature == null) {
		return null;
	}
	return semanticElement.eClass().getEStructuralFeature(feature);
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected AbstractElement getEntryGrammarElement(ICompositeNode entryPoint) {
	EObject grammarElement = entryPoint.getGrammarElement();
	if (grammarElement instanceof RuleCall) {
		AbstractRule rule = ((RuleCall) grammarElement).getRule();
		if (rule instanceof ParserRule) {
			if (!GrammarUtil.isMultipleCardinality(rule.getAlternatives())) {
				grammarElement = rule.getAlternatives();
			}
		}
	} else if (grammarElement instanceof ParserRule) {
		grammarElement = ((ParserRule) grammarElement).getAlternatives();
	} else if (grammarElement instanceof CrossReference) {
		grammarElement = GrammarUtil.containingAssignment(grammarElement);
	}
	AbstractElement result = (AbstractElement) grammarElement;
	if (result instanceof Action) {
		return getEntryGrammarElement((ICompositeNode) entryPoint.getFirstChild());
	}
	return result;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
/**
 * Get the name assigned feature in an Assignment rule call.
 *
 * @param call
 *          a rule call
 * @return the assigned feature
 */
private String getAssignedFeature(final RuleCall call) {
  Assignment ass = GrammarUtil.containingAssignment(call);
  if (ass != null) {
    String result = ass.getFeature();
    if (result.equals(result.toLowerCase())) { // NOPMD
      result = Strings.toFirstUpper(result);
    }
    return result;
  }
  return null;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected void collectReachableRules(ParserRule pr, Set<ParserRule> rules, Set<ParserRule> visited) {
	if (!visited.add(pr))
		return;
	for (RuleCall rc : GrammarUtil.containedRuleCalls(pr))
		if (isParserRule(rc.getRule())) {
			if (GrammarUtil.containingAssignment(rc) != null)
				rules.add((ParserRule) rc.getRule());
			collectReachableRules((ParserRule) rc.getRule(), rules, visited);
		}
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Check
public void checkUnassignedRuleCallAllowed(final RuleCall call) {
	if (call.getRule() != null && !call.getRule().eIsProxy() && GrammarUtil.containingAssignment(call) == null) {
		AbstractRule container = GrammarUtil.containingRule(call);
		if (call.getRule() instanceof ParserRule) {
			if (container instanceof TerminalRule) {
				getMessageAcceptor().acceptError(
						"Cannot call parser rule from terminal rule.", 
						call, 
						XtextPackage.Literals.RULE_CALL__RULE,
						ValidationMessageAcceptor.INSIGNIFICANT_INDEX,
						null);
			} else {
				ParserRule parserRule = (ParserRule) call.getRule();
				if (!GrammarUtil.isDatatypeRule(parserRule) && !parserRule.isFragment()) {
					checkCurrentMustBeUnassigned(call);
				}
			}
		}
		if (call.getRule() instanceof EnumRule) {
			if (container instanceof TerminalRule) {
				getMessageAcceptor().acceptError(
						"Cannot call enum rule from terminal rule.", 
						call, 
						XtextPackage.Literals.RULE_CALL__RULE,
						ValidationMessageAcceptor.INSIGNIFICANT_INDEX,
						null);
			}
		}
	}
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Override
protected String serializeInternal(INode node) {
	if (type == null)
		return null;
	switch (type) {
		case CROSS_REFERENCE:
			String ref = crossRefSerializer.serializeCrossRef(eObjectConsumer.getEObject(),
					(CrossReference) element, (EObject) value, node);
			if (ref == null) {
				Assignment ass = GrammarUtil.containingAssignment(element);
				throw new XtextSerializationException("Could not serialize cross reference from "
						+ EmfFormatter.objPath(eObjectConsumer.getEObject()) + "." + ass.getFeature() + " to "
						+ EmfFormatter.objPath((EObject) value));
			}
			return ref;
		case KEYWORD:
			return keywordSerializer.serializeAssignedKeyword(eObjectConsumer.getEObject(),
					((Keyword) element), value, node);
		case TERMINAL_RULE_CALL:
			return valueSerializer.serializeAssignedValue(eObjectConsumer.getEObject(), (RuleCall) element,
					value, node);
		case ENUM_RULE_CALL:
			return enumLitSerializer.serializeAssignedEnumLiteral(eObjectConsumer.getEObject(),
					(RuleCall) element, value, node);
		case PARSER_RULE_CALL:
			return null;
		case DATATYPE_RULE_CALL:
			return valueSerializer.serializeAssignedValue(eObjectConsumer.getEObject(), (RuleCall) element,
					value, node);
		default:
			return null;
	}
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Override
public boolean equalsOrReplacesNode(EObject context, RuleCall ruleCall, Object value, INode node) {
	if (ruleCall != node.getGrammarElement())
		return false;
	Assignment ass = GrammarUtil.containingAssignment(ruleCall);
	if (GrammarUtil.isSingleAssignment(ass))
		return true;
	Object converted = converter.toValue(serialize(node), ruleCall.getRule().getName(), node);
	return converted != null && converted.equals(value);
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected String addAssignemnt(String result, AbstractElement ele) {
	if (!showAssignment)
		return result;
	Assignment ass = GrammarUtil.containingAssignment(ele);
	result = ass != null ? ass.getFeature() + ass.getOperator() + result : result;
	return addQualified(result, ele);
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
/**
 * @since 2.0
 */
protected EClass getConstructedType(AbstractElement ele) {
	if (ele instanceof Action)
		return (EClass) ((Action) ele).getType().getClassifier();
	if (GrammarUtil.containingAssignment(ele) != null)
		return (EClass) GrammarUtil.containingRule(ele).getType().getClassifier();
	return null;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected String getToken(RuleCall rc, Object value, INode node) {
	CrossReference crossRef = GrammarUtil.containingCrossReference(rc);
	Assignment assignment = GrammarUtil.containingAssignment(rc);
	if (crossRef != null)
		return provider.crossRefSerializer.serializeCrossRef(semanticObject, crossRef, (EObject) value, node,
				errorAcceptor);
	else if (GrammarUtil.isEObjectRuleCall(rc) || GrammarUtil.isBooleanAssignment(assignment))
		return null;
	else if (GrammarUtil.isEnumRuleCall(rc))
		return provider.enumLiteralSerializer.serializeAssignedEnumLiteral(semanticObject, rc, value, node,
				errorAcceptor);
	else
		return provider.valueSerializer.serializeAssignedValue(semanticObject, rc, value, node, errorAcceptor);
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Override
public boolean isBooleanAssignment() {
	if (booleanAssignment == null) {
		Assignment assignment = GrammarUtil.containingAssignment(assignedGrammarElement);
		booleanAssignment = assignment != null && GrammarUtil.isBooleanAssignment(assignment);
	}
	return booleanAssignment;
}