Java 类org.eclipse.xtext.nodemodel.BidiIterator 实例源码

@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);
}