Java GrammarUtil.isDatatypeRuleCall方法代码示例

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
private List<String> getNodeSequence(EObject model) {
	List<String> result = Lists.newArrayList();
	GrammarElementTitleSwitch titleSwitch = new GrammarElementTitleSwitch().showAssignments();
	org.eclipse.xtext.serializer.sequencer.EmitterNodeIterator ni = 
			new org.eclipse.xtext.serializer.sequencer.EmitterNodeIterator(NodeModelUtils.findActualNodeFor(model));
	while (ni.hasNext()) {
		INode next = ni.next();
		EObject ele = next.getGrammarElement() instanceof CrossReference ? ((CrossReference) next
				.getGrammarElement()).getTerminal() : next.getGrammarElement();
		if (next instanceof ILeafNode || GrammarUtil.isDatatypeRuleCall(ele))
			result.add(titleSwitch.doSwitch(ele) + " -> " + next.getText().trim());
		else if (next instanceof ICompositeNode)
			result.add(titleSwitch.doSwitch(ele));
	}
	return result;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected boolean include(INode node) {
	if (node instanceof ILeafNode) {
		ILeafNode leaf = (ILeafNode) node;
		if (!allowHidden && leaf.isHidden())
			return false;
		return true;
	} else if (node instanceof ICompositeNode) {
		return GrammarUtil.isDatatypeRuleCall(node.getGrammarElement())
				|| node.getGrammarElement() instanceof CrossReference;
	}
	return false;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
private static boolean isEmitter(INode node, EObject grammarElement) {
	if (node instanceof ILeafNode) {
		ILeafNode leaf = (ILeafNode) node;
		if (leaf.isHidden())
			return false;
		return true;
	} else if (node instanceof ICompositeNode) {
		return GrammarUtil.isDatatypeRuleCall(grammarElement) || grammarElement instanceof CrossReference;
	}
	return false;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
protected boolean include(INode node) {
	if (node instanceof ILeafNode) {
		return true;
	} else if (node instanceof ICompositeNode) {
		EObject element = node.getGrammarElement();
		return GrammarUtil.isDatatypeRuleCall(element) || element instanceof CrossReference
				|| GrammarUtil.isEnumRuleCall(element);
	}
	return false;
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
@Override
public boolean apply(ISynState input) {
	AbstractElement ge = input.getGrammarElement();
	return ge instanceof Keyword || GrammarUtil.isDatatypeRuleCall(ge) || GrammarUtil.isEnumRuleCall(ge)
			|| GrammarUtil.isTerminalRuleCall(ge);
}
 

import org.eclipse.xtext.GrammarUtil; //导入方法依赖的package包/类
/**
 * Collects all the hidden tokens between two given nodes of the node model.
 *
 * @param from
 *          node that serves as a start point, must not be {@code null}
 * @param to
 *          search end point, must not be {@code null}
 * @param deletedSemanticElements
 *          set of the deleted semantic elements, must not be {@code null}
 * @return list of hidden tokens, never {@code null}, but can be empty
 */
private List<INode> getHiddenTokensBetween(final INode from, final INode to, final Set<EObject> deletedSemanticElements) {
  EObject fromElement = NodeModelUtils.findActualSemanticObjectFor(from);
  if (from.equals(NodeModelUtils.getNode(fromElement))) {
    // If the starting node represents some container, emit the comments that belong to it
    // This is needed to correctly handle some edge cases like ImportList in AvqScript
    // Logic for distinguishing between container's comments and the ones of first element is expected to be implemented in 'isLeadingCommentFor'
    emitContainerComments(from);
  }
  List<INode> result = Lists.newArrayList();
  boolean handleReordering = from.getTotalOffset() > to.getTotalOffset();
  if (!handleReordering) {
    // Elements are not reordered
    // Just going through the interval and collecting comments, unless they have already been emitted
    NodeIterator nodes = new NodeIterator(from);
    while (nodes.hasNext()) {
      INode next = nodes.next();
      if (tokenUtil.isWhitespaceOrCommentNode(next)) {
        if (!emittedComments.contains(next)) {
          result.add(next);
        }
      } else if (next.equals(to)) {
        // We have hit the 'to' node
        // If it is a composite one, we have to iterate through its children
        // and collect whitespaces/comments until we encounter first token (keyword, identifier...)
        if (next instanceof ICompositeNode && (GrammarUtil.isDatatypeRuleCall(next.getGrammarElement())
            || GrammarUtil.isEnumRuleCall(next.getGrammarElement()) || next.getGrammarElement() instanceof CrossReference)) {
          while (nodes.hasNext()) {
            INode lastNodeChild = nodes.next();
            if (tokenUtil.isWhitespaceOrCommentNode(lastNodeChild)) {
              if (!emittedComments.contains(lastNodeChild)) {
                result.add(lastNodeChild);
              }
            } else if (lastNodeChild instanceof ILeafNode) {
              break;
            }
          }
          break;
        } else {
          // 'to' node is not a composite one, nothing to do here, just exit the loop
          break;
        }
      } else if (belongsToDeletedElement(next)) {
        handleDeletedElement(result, deletedSemanticElements, next);
        nodes.prune();
      } else if (tokenUtil.isToken(next)) {
        // We have encountered some token, but not the one we expected
        // Will be handled by invoking 'getLeadingCommentsIncludingWhitespace' method later
        handleReordering = true;
        break;
      }
    }
  }
  if (handleReordering) {
    return getLeadingCommentsIncludingWhitespace(to);
  }
  return result;
}