Java MatcherContext.advanceIndex方法代码示例

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public final <V> boolean match(final MatcherContext<V> context) {
    if (!isAllowedChar(context.getCurrentChar())) {
        return false;
    }
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public final <V> boolean match(MatcherContext<V> context) {
    if (!acceptChar(context.getCurrentChar())) {
        return false;
    }
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public <V> boolean match(MatcherContext<V> context) {

    int cur = context.getCurrentIndex();

    InputBuffer buffer = context.getInputBuffer();
    String content = InputBufferUtils.collectContent(buffer);
    content = content.substring(cur);
    Matcher m = pattern.matcher(content);

    if(m.find()) {

        int start = m.start();
        if(start == 0) {
            int end = m.end();

            int delta = end - start;

            context.advanceIndex(delta);

            context.createNode();
            return true;

        } else {
            return false;
        }
    } else {

        return false;
    }

}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override public boolean match(MatcherContext<Node> context) {
	char current = context.getCurrentChar();
	if (Character.isJavaIdentifierPart(current)) {
		context.advanceIndex();
		context.createNode();
		return true;
	}
	return false;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public boolean match(MatcherContext context) {
    if (!context.fastStringMatching()) {
        return super.match(context);
    }

    Record rec = root;
    int ix = context.getCurrentIndex();
    InputBuffer buffer = context.getInputBuffer();
    char c = context.getCurrentChar();
    int endIx = -1;

    loop:
    while (true) {
        char[] chars = rec.chars;
        for (int i = 0; i < chars.length; i++) {
            if (c == chars[i]) {
                ix++;
                rec = rec.subs[i];
                if (rec == null) { // success, we complected a tree path to a leave
                    endIx = ix;
                    break loop;
                }
                if (rec.complete) { // we completed a valid match path, but continue looking for a longer match
                    endIx = ix;
                }
                c = buffer.charAt(ix);
                continue loop;
            }
        }
        // we checked all sub branches of the current node, none matched, so we are done
        break;
    }

    if (endIx == -1) return false; // we matched no complete path, so fail

    context.advanceIndex(endIx - context.getCurrentIndex());
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    switch (context.getCurrentChar()) {
        case Chars.DEL_ERROR:
        case Chars.INS_ERROR:
        case Chars.RESYNC:
        case Chars.RESYNC_START:
        case Chars.RESYNC_END:
        case Chars.RESYNC_EOI:
        case Chars.EOI:
            return false;
    }
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public boolean match(MatcherContext context) {
    if (!context.fastStringMatching()) {
        return super.match(context);
    }

    if (!context.getInputBuffer().test(context.getCurrentIndex(), characters)) return false;
    context.advanceIndex(characters.length);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    char c = context.getCurrentChar();
    if (c != charLow && c != charUp) return false;
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    char c = context.getCurrentChar();
    if (c < cLow || c > cHigh) return false;

    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
private boolean willMatchDelError(MatcherContext context) {
    int preSkipIndex = context.getCurrentIndex();
    context.advanceIndex(2); // skip del marker char and illegal char
    if (!runTestMatch(context)) {
        // if we wouldn't succeed with the match do not swallow the ERROR char & Co
        context.setCurrentIndex(preSkipIndex);
        return false;
    }
    context.setStartIndex(context.getCurrentIndex());
    if (context.getParent() != null) context.getParent().markError();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
private boolean willMatchInsError(MatcherContext context) {
    int preSkipIndex = context.getCurrentIndex();
    context.advanceIndex(1); // skip ins marker char
    if (!runTestMatch(context)) {
        // if we wouldn't succeed with the match do not swallow the ERROR char
        context.setCurrentIndex(preSkipIndex);
        return false;
    }
    context.setStartIndex(context.getCurrentIndex());
    context.markError();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
private int gobbleIllegalCharacters(MatcherContext context, List<Matcher> followMatchers) {
    while_loop:
    while (true) {
        char currentChar = context.getCurrentChar();
        if (currentChar == EOI) break;
        for (Matcher followMatcher : followMatchers) {
            if (followMatcher.accept(new IsStarterCharVisitor(currentChar))) {
                break while_loop;
            }
        }
        context.advanceIndex(1);
    }
    return context.getCurrentIndex();
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public final <V> boolean match(MatcherContext<V> context) {
    if (!acceptChar(context.getCurrentChar())) {
        return false;
    }
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    if (context.getCurrentChar() != character) return false;
    context.advanceIndex(1);
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    if (!characters.contains(context.getCurrentChar())) return false;
    context.advanceIndex(1);
    context.createNode();
    return true;
}