Java MatcherContext.createNode方法代码示例

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@Override
public <V> boolean match(MatcherContext<V> context) {
    int cur = context.getCurrentIndex();
    if(cur == 0) {
        context.createNode();
        return true;
    }
    InputBuffer buffer = context.getInputBuffer();

    if(buffer.charAt(cur-1)=='\n') {
        context.createNode();
        return true;
    }

    return false;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    Object valueStackSnapshot = context.getValueStack().takeSnapshot();

    List<Matcher> children = getChildren();
    int size = children.size();
    for (int i = 0; i < size; i++) {
        Matcher matcher = children.get(i);

        // remember the current index in the context, so we can access it for building the current follower set
        context.setIntTag(i);

        if (!matcher.getSubContext(context).runMatcher()) {
            // rule failed, so invalidate all stack actions the rule might have done
            context.getValueStack().restoreSnapshot(valueStackSnapshot);
            return false;
        }
    }
    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
public boolean match(MatcherContext context) {
    boolean matched = subMatcher.getSubContext(context).runMatcher();
    if (!matched) return false;

    // collect all further matches as well
    int lastIndex = context.getCurrentIndex();
    while (subMatcher.getSubContext(context).runMatcher()) {
        int currentIndex = context.getCurrentIndex();
        if (currentIndex == lastIndex) {
            throw new GrammarException("The inner rule of OneOrMore rule '%s' must not allow empty matches",
                    context.getPath());
        }
        lastIndex = currentIndex;
    }

    context.createNode();
    return true;
}
 

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) {
    checkArgNotNull(context, "context");
    int lastIndex = context.getCurrentIndex();
    while (subMatcher.getSubContext(context).runMatcher()) {
        int currentLocation = context.getCurrentIndex();
        if (currentLocation == lastIndex) {
            throw new GrammarException("The inner rule of ZeroOrMore rule '%s' must not allow empty matches",
                    context.getPath());
        }
        lastIndex = currentLocation;
    }

    context.createNode();
    return true;
}
 

import org.parboiled.MatcherContext; //导入方法依赖的package包/类
@SuppressWarnings( {"ForLoopReplaceableByForEach"})
public boolean match(MatcherContext context) {
    List<Matcher> children = getChildren();
    int size = children.size();
    for (int i = 0; i < size; i++) {
        Matcher matcher = children.get(i);
        if (matcher.getSubContext(context).runMatcher()) {
            context.createNode();
            return true;
        }
    }
    return false;
}
 

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包/类
public final <V> boolean match(MatcherContext<V> context) {
    if (!acceptChar(context.getCurrentChar())) {
        return false;
    }
    context.advanceIndex(1);
    context.createNode();
    return true;
}