Java TokenHierarchy.embeddedTokenSequences方法代码示例

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
private boolean sameCommentHandler(TokenHierarchy<?> th, int offset, boolean backwardBias, CommentHandler cH) {
    CommentHandler cH2 = null;
    List<TokenSequence<?>> seqs = th.embeddedTokenSequences(offset, backwardBias);
    if (!seqs.isEmpty()) {
        for(int i = seqs.size() - 1; i >= 0; i--) {
            TokenSequence<?> ts = seqs.get(i);
            Language lang = LanguageRegistry.getInstance().getLanguageByMimeType(ts.language().mimeType());
            if (lang != null) {
                if (lang.getGsfLanguage() instanceof DefaultLanguageConfig) {
                    cH2 = ((DefaultLanguageConfig) lang.getGsfLanguage()).getCommentHandler();
                }
                break;
            }
        }
    }

    return cH2 != null && cH.getClass() == cH2.getClass();
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
private static int scanForSemicolon(Document doc, int[] offset, int start, int end) throws BadLocationException {
    TokenHierarchy<Document> th = doc != null ? TokenHierarchy.get(doc) : null;
    List<TokenSequence<?>> embeddedSequences = th != null ? th.embeddedTokenSequences(offset[0], false) : null;
    TokenSequence<?> seq = embeddedSequences != null ? embeddedSequences.get(embeddedSequences.size() - 1) : null;

    if (seq == null) {
        return offset[0];
    }   

    seq.move(start);

    int semicolon = -1;
    while(seq.moveNext()) {
        int tokenOffset = seq.offset();
        if(tokenOffset > end) {
            break;
        }
        Token<?> t = seq.token();
        if(t != null && t.id() == JavaTokenId.SEMICOLON ) {
            semicolon = tokenOffset;
            break;
        }
    }
    return semicolon;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
public static List<TokenSequence<?>> getEmbeddedTokenSequences(
    TokenHierarchy<?> th, int offset, boolean backwardBias, Language<?> language
) {
    List<TokenSequence<?>> sequences = th.embeddedTokenSequences(offset, backwardBias);

    for(int i = sequences.size() - 1; i >= 0; i--) {
        TokenSequence<?> seq = sequences.get(i);
        if (seq.language() == language) {
            break;
        } else {
            sequences.remove(i);
        }
    }
    
    return sequences;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
public int getAutoQueryTypes (JTextComponent component, String typedText) {
    if (".".equals(typedText)) { // NOI18N
        Document doc = component.getDocument ();
        TokenHierarchy<Document> tokenHierarchy = TokenHierarchy.get (doc);
        if (doc instanceof NbEditorDocument)
            ((NbEditorDocument) doc).readLock ();
        try {
            int offset = component.getCaret().getDot();
            if (offset <= 1) {
                return 0;
            }
            offset = offset - 2; //do Schlieman's magic
            
            List<TokenSequence<?>> sequences = tokenHierarchy.embeddedTokenSequences(offset, true);
            if(sequences.isEmpty()) {
                return 0; //no token sequence
            }
            TokenSequence<?> tokenSequence = sequences.get(sequences.size() - 1); //get the most embedded
            tokenSequence.move(offset);
            if (!tokenSequence.moveNext() && !tokenSequence.movePrevious()) {
                return 0;
            }
            Token<?> token = tokenSequence.token ();
            if (token.id().name().indexOf("identifier") > -1) { // NOI18N [PENDING]
                return COMPLETION_QUERY_TYPE;
            }
        } finally {
            if (doc instanceof NbEditorDocument)
                ((NbEditorDocument) doc).readUnlock ();
        }
    }
    return 0;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
public static Language<? extends TokenId> getLanguage(TokenHierarchy<BaseDocument> th, int offset) {
    List<TokenSequence<?>> list = th.embeddedTokenSequences(offset, true);

    if (list.isEmpty()) {
        return null;
    }
    return list.get(list.size()-1).language();
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
private static boolean findHtmlValueToken(TokenHierarchy<?> hi, int offset, boolean backward) {
    List<TokenSequence<?>> embeddedTokenSequences = hi.embeddedTokenSequences(offset, backward);
    for (TokenSequence<?> htmlts : embeddedTokenSequences) {
        if (htmlts.language().mimeType().equals("text/html")) {
            //it relly looks like our parent ts
            int ediff = htmlts.move(offset);
            if (ediff == 0 && backward && htmlts.movePrevious() || htmlts.moveNext()) {
                TokenId id = htmlts.token().id();
                //XXX !!!! DEPENDENCY to HtmlTokenId !!!!
                return id.name().equals("VALUE_CSS");
            }
        }
    }
    return false;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
/**
 * Get token sequence positioned over a token.
 *
 * @param doc
 * @param caretOffset
 * @param backwardBias
 * @return token sequence positioned over a token that "contains" the offset
 * or null if the document does not contain any java token sequence or the
 * offset is at doc-or-section-start-and-bwd-bias or
 * doc-or-section-end-and-fwd-bias.
 */
private static TokenSequence<JavaTokenId> javaTokenSequence(Document doc, int caretOffset, boolean backwardBias) {
    TokenHierarchy<?> hi = TokenHierarchy.get(doc);
    List<TokenSequence<?>> tsList = hi.embeddedTokenSequences(caretOffset, backwardBias);
    // Go from inner to outer TSes
    for (int i = tsList.size() - 1; i >= 0; i--) {
        TokenSequence<?> ts = tsList.get(i);
        if (ts.languagePath().innerLanguage() == JavaTokenId.language()) {
            TokenSequence<JavaTokenId> javaInnerTS = (TokenSequence<JavaTokenId>) ts;
            return javaInnerTS;
        }
    }
    return null;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
private TokenSequence getTokenSequence(Document doc, int offset) {
    TokenHierarchy<Document> th = TokenHierarchy.get(doc);
    List<TokenSequence<?>> sequences = th.embeddedTokenSequences(offset, true);
    TokenSequence htmlTs = null;
    for (TokenSequence ts : sequences) {
        if (ts.language().mimeType().equals("text/html")) { //NOI18N
            htmlTs = ts;
            break;
        }
    }
    return htmlTs;
}
 

import org.netbeans.api.lexer.TokenHierarchy; //导入方法依赖的package包/类
public int[] findOrigin() throws BadLocationException, InterruptedException {
    ((AbstractDocument) context.getDocument()).readLock();
    try {
        int caretOffset = context.getSearchOffset();
        boolean backward = context.isSearchingBackward();

        TokenHierarchy<Document> th = TokenHierarchy.get(context.getDocument());
        List<TokenSequence<?>> sequences = th.embeddedTokenSequences(caretOffset, backward);

        for(int i = sequences.size() - 1; i >= 0; i--) {
            TokenSequence<? extends TokenId> seq = sequences.get(i);
            if (seq.language() == JavadocTokenId.language()) {
                jdocSeq = seq;
                if (i > 0) {
                    TokenSequence<? extends TokenId> javaSeq = sequences.get(i - 1);
                    jdocStart = javaSeq.offset();
                    jdocEnd = javaSeq.offset() + javaSeq.token().length();
                } else {
                    // jdocSeq is the top level sequence, ie the whole document is just javadoc
                    jdocStart = 0;
                    jdocEnd = context.getDocument().getLength();
                }
                break;
            }
        }

        if (jdocSeq == null) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Not javadoc TokenSequence."); //NOI18N
            }
            return null;
        }

//        if (caretOffset >= jdocStart && 
//            ((backward && caretOffset <= jdocStart + 3) ||
//            (!backward && caretOffset < jdocStart + 3))
//        ) {
//            matchingArea = new int [] { jdocEnd - 2, jdocEnd };
//            return new int [] { jdocStart, jdocStart + 3 };
//        }
//
//        if (caretOffset <= jdocEnd && 
//            ((backward && caretOffset > jdocEnd - 2) ||
//            (!backward && caretOffset >= jdocEnd - 2))
//        ) {
//            matchingArea = new int [] { jdocStart, jdocStart + 3 };
//            return new int [] { jdocEnd - 2, jdocEnd };
//        }

        // look for tags first
        jdocSeq.move(caretOffset);
        if (jdocSeq.moveNext()) {
            if (isTag(jdocSeq.token()) && !isTypeParameterTag(jdocSeq) && !isUninterpretedTag(jdocSeq)) {
                if (jdocSeq.offset() < caretOffset || !backward) {
                    return prepareOffsets(jdocSeq, true);
                }
            }

            while(moveTheSequence(jdocSeq, backward, context.getLimitOffset())) {
                if (isTag(jdocSeq.token())) {
                    if (isTypeParameterTag(jdocSeq) || isUninterpretedTag(jdocSeq)) {
                        // do not treat type parameter and {@code} and {@literal} content as HTML tag
                        break;
                    }
                    return prepareOffsets(jdocSeq, true);
                }
            }
        }

        defaultMatcher = BracesMatcherSupport.defaultMatcher(context, jdocStart, jdocEnd);
        return defaultMatcher.findOrigin();
    } finally {
        ((AbstractDocument) context.getDocument()).readUnlock();
    }
}