@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; } }; }
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(); }
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 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 ); } }
private 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; }
@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(); }
/** * @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(); }
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; } } } }
/** * @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()); }
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"); }
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; } } } }
@Override public BidiIterator<INode> iterator() { return new NodeIterator(startWith); }
@Override public BidiIterator<T> iterator() { return SingletonBidiIterator.<T>create(value); }
@Override public BidiIterator<T> iterator() { BidiIterator<T> delegate = getDelegate().iterator(); return new ReversedBidiIterator<T>(delegate); }
@SuppressWarnings("unchecked") public static <T> BidiIterator<T> instance() { return (BidiIterator<T>) INSTANCE; }
public ReversedBidiIterator(BidiIterator<T> delegate) { this.delegate = delegate; }
protected BidiIterator<T> getDelegate() { return delegate; }
public static <T> BidiIterator<T> create(T t) { return new SingletonBidiIterator<T>(t); }
@Override public BidiIterator<T> iterator() { return EmptyBidiIterator.instance(); }
@Override public BidiIterator<AbstractNode> iterator() { return new BasicNodeIterator(startWith); }