org.eclipse.xtext.nodemodel.BidiIterator Java Examples

public static String getTypeRefName(TypeRef typeRef) {
	if (typeRef.getClassifier() != null)
		return typeRef.getClassifier().getName();
	final ICompositeNode node = NodeModelUtils.getNode(typeRef);
	if (node != null) {
		final BidiIterator<INode> leafNodes = node.getAsTreeIterable().iterator();
		while (leafNodes.hasPrevious()) {
			INode previous = leafNodes.previous();
			if (previous instanceof ILeafNode && !((ILeafNode) previous).isHidden()) {
				String result = previous.getText();
				if (result != null && result.startsWith("^")) {
					result = result.substring(1);
				}
				return result;
			}
		}
	}
	return null;
}
 

private void provideHighLightForNamedElement(NamedElement namedElement, INode nextNode, String textStyle,
		IHighlightedPositionAcceptor acceptor) {
	acceptor.addPosition(nextNode.getOffset(), nextNode.getLength(), textStyle);
	List<ElementReferenceExpression> references = EcoreUtil2.getAllContentsOfType(namedElement.eContainer(),
			ElementReferenceExpression.class);
	for (ElementReferenceExpression elementReferenceExpression : references) {
		EObject reference = elementReferenceExpression.getReference();
		if (reference.equals(namedElement)) {
			ICompositeNode referencingNode = NodeModelUtils.findActualNodeFor(elementReferenceExpression);
			BidiIterator<INode> bidiIterator = referencingNode.getChildren().iterator();
			while (bidiIterator.hasNext()) {
				INode currentNode = bidiIterator.next();
				if (currentNode.getText().trim().equals(namedElement.getName())) {
					acceptor.addPosition(currentNode.getOffset(), currentNode.getLength(), textStyle);
				}
			}
		}
	}
}
 

private List<EObject> getLinkedMetaModel(TypeRef context, EReference ref, ILeafNode text) throws IllegalNodeException {
	final ICompositeNode parentNode = text.getParent();
	BidiIterator<INode> iterator = parentNode.getChildren().iterator();
	while(iterator.hasPrevious()) {
		INode child = iterator.previous();
		if (child instanceof ILeafNode) {
			ILeafNode leaf = (ILeafNode) child;
			if (text == leaf)
				return super.getLinkedObjects(context, ref, text);
			if (!(leaf.getGrammarElement() instanceof Keyword) && !leaf.isHidden()) {
				IScope scope = getScope(context, ref);
				return XtextMetamodelReferenceHelper.findBestMetamodelForType(
						context, text.getText(), leaf.getText(), scope);
			}
		}
	}
	return Collections.emptyList();
}
 

@Override
public BidiIterable<AbstractNode> reverse() {
	return new BidiIterable<AbstractNode>() {

		@Override
		public BidiIterator<AbstractNode> iterator() {
			BidiIterator<AbstractNode> delegate = BasicNodeIterable.this.iterator(); 
			return new ReversedBidiIterator<AbstractNode>(delegate);
		}

		@Override
		public BidiIterable<AbstractNode> reverse() {
			return BasicNodeIterable.this;
		}
	};
}
 

INode skipWhiteSpace(IHighlightedPositionAcceptor acceptor,
		BidiIterator<INode> it) {
	INode n = null;
	while (it.hasNext()
			&& (n = it.next()).getClass() == HiddenLeafNode.class)
		processHiddenNode(acceptor, (HiddenLeafNode) n);
	return n;
}
 

private void collectNodesEnclosingChangeRegion(final ICompositeNode parent, final Range range, final List<ICompositeNode> nodesEnclosingRegion) {
  nodesEnclosingRegion.add(parent);
  BidiIterator<INode> iterator = parent.getChildren().iterator();
  while (iterator.hasPrevious()) {
    INode prev = iterator.previous();
    if (prev instanceof ICompositeNode) {
      if (nodeEnclosesRegion((ICompositeNode) prev, range)) {
        collectNodesEnclosingChangeRegion((ICompositeNode) prev, range, nodesEnclosingRegion);
        break;
      }
    }
  }
}
 

protected INode findContextNode(EObject semanticObject) {
	INode node = NodeModelUtils.findActualNodeFor(semanticObject);
	if (node != null) {
		BidiIterator<INode> nodes = node.getAsTreeIterable().iterator();
		while (nodes.hasNext()) {
			INode next = nodes.next();
			if (next.getGrammarElement() instanceof RuleCall)
				return next;
			if (next.getGrammarElement() instanceof ParserRule
					&& ((ParserRule) next.getGrammarElement()).getType().getClassifier() instanceof EClass)
				return next;
		}
	}
	throw new RuntimeException("no context found");
}
 

/**
 * @return either a RuleCall or a ParserRule
 */
public EObject findEntryRuleOrRuleCall(ICompositeNode replaceRootNode) {
	EObject grammarElement = replaceRootNode.getGrammarElement();
	if (grammarElement instanceof CrossReference) {
		grammarElement = ((CrossReference) grammarElement).getTerminal();
	}
	if (GrammarUtil.isParserRuleCall(grammarElement)) {
		return grammarElement;
	}
	else if (grammarElement instanceof ParserRule) {
		return grammarElement;
	}
	else if (grammarElement instanceof Action) {
		BidiIterator<INode> iterator = replaceRootNode.getChildren().iterator();
		while(iterator.hasNext()) {
			INode next = iterator.next();
			if (next instanceof ICompositeNode) {
				return findEntryRuleOrRuleCall((ICompositeNode) next);
			}
		}
		throw new IllegalArgumentException("Invalid parsetree: Action node does not have a Composite child");
	}
	else
		throw new IllegalArgumentException(
				"Entry rule can only be resolved for parser rules, rule calls, cross-references or actions, but tried to resolve for: "
				+ replaceRootNode.getGrammarElement().eClass().getName());
}
 

private void collectNodesEnclosingChangeRegion(ICompositeNode parent, Range range,
		List<ICompositeNode> nodesEnclosingRegion) {
	nodesEnclosingRegion.add(parent);
	BidiIterator<INode> iterator = parent.getChildren().iterator();
	while(iterator.hasPrevious()) {
		INode prev = iterator.previous();
		if (prev instanceof ICompositeNode) {
			if (nodeEnclosesRegion((ICompositeNode) prev, range)) {
				collectNodesEnclosingChangeRegion((ICompositeNode) prev, range, nodesEnclosingRegion);
				break;
			}
		}
	}
}
 

/**
 * @since 2.5
 */
@Override
public int getEndOffset() {
	BidiIterator<AbstractNode> iter = basicIterator();
	while(iter.hasPrevious()) {
		INode prev = iter.previous();
		if (prev instanceof ILeafNode && !((ILeafNode) prev).isHidden()) {
			return prev.getTotalEndOffset();
		}
	}
	return getTotalEndOffset();
}
 

@Override
public int getLength() {
	BidiIterator<AbstractNode> iter = basicIterator();
	while(iter.hasPrevious()) {
		INode prev = iter.previous();
		if (prev instanceof ILeafNode && !((ILeafNode) prev).isHidden()) {
			int offset = getOffset();
			return prev.getTotalEndOffset() - offset;
		}
	}
	return getTotalLength();
}
 

INode skipWhiteSpaceBackwards(IHighlightedPositionAcceptor acceptor,
		BidiIterator<INode> it) {
	INode n = null;
	while (it.hasPrevious()
			&& (n = it.previous()).getClass() == HiddenLeafNode.class)
		processHiddenNode(acceptor, (HiddenLeafNode) n);
	return n;
}
 

void setStyles(IHighlightedPositionAcceptor acceptor,
		BidiIterator<INode> it, String... styles) {
	for (String s : styles) {
		if (!it.hasNext())
			return;
		INode n = skipWhiteSpace(acceptor, it);
		if (n != null && s != null)
			acceptor.addPosition(n.getOffset(), n.getLength(), s);
	}
}
 

@Override
public BidiIterator<T> iterator() {
	return EmptyBidiIterator.instance();
}
 

public static <T> BidiIterator<T> create(T t) {
	return new SingletonBidiIterator<T>(t);
}
 

protected BidiIterator<T> getDelegate() {
	return delegate;
}
 

@Override
public BidiIterator<AbstractNode> iterator() {
	return new BasicNodeIterator(startWith);
}
 

public ReversedBidiIterator(BidiIterator<T> delegate) {
	this.delegate = delegate;
}
 

@SuppressWarnings("unchecked")
public static <T> BidiIterator<T> instance() {
	return (BidiIterator<T>) INSTANCE;
}
 

@Override
public BidiIterator<T> iterator() {
	BidiIterator<T> delegate = getDelegate().iterator(); 
	return new ReversedBidiIterator<T>(delegate);
}
 

@Override
public BidiIterator<T> iterator() {
	return SingletonBidiIterator.<T>create(value);
}
 

@Override
public BidiIterator<INode> iterator() {
	return new NodeIterator(startWith);
}