Java Rule类代码示例

import org.parboiled.Rule; //导入依赖的package包/类
Rule operatorSymbolRule(String operatorSymbol) {
    if (!operatorSymbol.contains(" ")) {
        return operatorSymbol.length() == 1 ?
                Ch(operatorSymbol.charAt(0)) :
                String(operatorSymbol);
    }

    LinkedList<Rule> symbolParts = new LinkedList<>();
    String[] parts = operatorSymbol.split(" ");
    for (int i = 0; i < parts.length; i++) {
        Rule operatorValue = parts[i].length() == 1 ?
                Ch(parts[i].charAt(0)) :
                String(parts[i]);

        symbolParts.add(operatorValue);

        if ((i + 1) < parts.length) {
            symbolParts.add(Ch(' '));
        }
    }

    return Sequence(symbolParts.toArray(new Object[0]));
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Object[] operatorParts(Operator operatorType, Object... moreRules) {

        Set<String> symbols = operatorType.getOperatorSymbols(config.getGrammar());

        LinkedList<Rule> symbolsRule = new LinkedList<>();
        for (String symbol : symbols) {
            symbolsRule.add(operatorSymbolRule(symbol));
        }

        Rule rule = FirstOf(symbolsRule.toArray(new Object[0]));

        LinkedList<Object> allRules = new LinkedList<>();
        allRules.add(rule);
        allRules.addAll(Arrays.asList(moreRules));

        return allRules.toArray(new Object[0]);
    }
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule Order() {
    ListVar<OrderNode.OrderSpecifier> list = new ListVar<>();
    OrderVar orderVar = new OrderVar();

    return Sequence(
            toOperator(QueryOperatorType.ORDER),
            WS(),
            OrderSpecifier(orderVar),
            list.add(orderVar.get()),
            orderVar.clear(),
            ZeroOrMore(Sequence(OptionalWS(),
                    String(config.getGrammar().getArgsSeparator()),
                    OptionalWS(),
                    OrderSpecifier(orderVar),
                    list.add(orderVar.get()),
                    orderVar.clear()
            )), pushOrderByOperation(list.get()));
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule TextBlock() {
  return Sequence(TextBlock.builder(),
      TextFragment(), TextBlock.addParts(TextFragment.of()),
      ZeroOrMore(Sequence(
          Newline(), TextBlock.addParts(Newline.of()),
          TextFragment(), TextBlock.addParts(TextFragment.of()))),
      TextBlock.build());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule TemplateBody() {
  return Sequence(
      TextBlock(), Template.addParts(),
      ZeroOrMore(
      Sequence(
          Directive(), Template.addParts(),
          TextBlock(), Template.addParts())));
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule DirectiveEnd() {
  return ClosingDirective(FirstOf(
      IfEnd(),
      LetEnd(),
      ForEnd(),
      InvokeEnd()));
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule AccessExpression() {
  return Sequence(SimpleAccessExpression.builder(),
      Identifier(), SimpleAccessExpression.addPath(),
      ZeroOrMore(Sequence(DOT,
          Identifier(), SimpleAccessExpression.addPath())),
      SimpleAccessExpression.build());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule IterationGenerator() {
  return Sequence(IterationGenerator.builder(),
      ValueDeclaration(), IterationGenerator.declaration(),
      IN,
      Expression(), IterationGenerator.from(),
      Optional(IF, Expression(), IterationGenerator.condition()),
      IterationGenerator.build());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule AssignGenerator() {
  return Sequence(AssignGenerator.builder(),
      ValueDeclaration(), AssignGenerator.declaration(),
      ASSIGN,
      Expression(), AssignGenerator.from(),
      AssignGenerator.build());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule TransformGenerator() {
  return Sequence(TransformGenerator.builder(),
      ValueDeclaration(), TransformGenerator.declaration(),
      ASSIGN,
      Expression(), TransformGenerator.transform(),
      FOR,
      ValueDeclaration(), TransformGenerator.varDeclaration(),
      IN,
      Expression(), TransformGenerator.from(),
      Optional(IF, Expression(), TransformGenerator.condition()),
      TransformGenerator.build());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
@DontLabel
Rule DisambiguatedExpression() {
  return FirstOf(
      Parens(ApplyExpression()),
      ForIterationAccessExpression(),
      AccessExpression(),
      StringLiteral());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule ParameterDeclaration() {
  return Sequence(Parameter.builder(),
      Type(), Parameter.type(),
      Name(), Parameter.name(),
      Parameter.build(),
      InvokableDeclaration.addParameters());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
Rule InOperation() {
    ListVar<Object> list = new ListVar<>();
    return Sequence(Selector(), WS(), FirstOf(NotInOperator(), InOperator()),
            OptionalWS(),
            Ch('('),
            OptionalWS(), Arguments(list), OptionalWS(),
            Ch(')'), pushListOperation(list.get()));
}
 

import org.parboiled.Rule; //导入依赖的package包/类
@DontLabel
@SuppressSubnodes
Rule Literal(String string) {
  return Sequence(
      String(string),
      Spacing());
}
 

import org.parboiled.Rule; //导入依赖的package包/类
@SuppressSubnodes
@MemoMismatches
Rule Identifier() {
  return Sequence(
      TestNot(Keyword()),
      Sequence(Sequence(IdentifierStartLetter(), ZeroOrMore(LetterOrDigit())), Identifier.of()),
      Spacing());
}